进程调度模拟程序
南京邮电大学-操作系统实验报告
课内实验报告课程名：操作系统任课教师：沈超专业：信息管理与信息系统学号：姓名：二○一六至二○一七年度第一学期南京邮电大学经济与管理学院Process[numberschedul].order=tempcounter;}程序结果截图：二、银行家算法（网上借鉴）银行家算法，当进程提出资源申请时，系统首先检查该进程对资源的申请量是否超过其最大需求量及系统现有的资源能否满足进程需要。
若超过，则报错，若不能满足，则让该进程等待；否则进一步检查把资源分给该进程后系统能否出于安全状态，若安全，则分配，否则置该进程为等待资源状态。
算法实现过程：设进程i 提出请求REQUEST [j] ，则银行家算法按如下规则进行判断。
(1) 如果REQUEST [i] [j]<= NEED[i][j] ，则转(2) ；否则，出错。
(2) 如果REQUEST [i] [j]<= A V AILABLE[i][j] ，则转(3) ；否则，出错。
(3) 系统试探分配资源，修改相关数据：A V AILABLE[j]-=REQUEST[i][j];ALLOCATION[i][j]+=REQUEST[i][j];NEED[i][j]-=REQUEST[i][j];(4) 系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
Check（）关键代码：{int k, f, no=0;int work[M],a[M];char finish[M];anquan=1;for(i=0;i<n; i++) finish[i]='F';for(j=0;j<m; j++) work[j]=available[j]; k=n;do{ for (i=0;i<n; i++){if (finish[i]=='F'){ f=1;for (j=0;j<m; j++)if (need[i][j]>work[j]) printf("处于安全状态.");printf("安全序列号:");for (i=0;i<n;i++) printf ("%d ",a[i]); printf("\n");printf("进程");printf(" ");printf(" Max ");rintf(" ");rintf("allocation");printf(" ");printf("need");printf(" ");f=0;if (f==1)//找到还没完成的且需求数小于可提供进程继续运行的{ finish[i]='T';a[no++]=i;//记录安全序列号for (j=0;j<m; j++)work[j]=work[j]+allocation[i][j];//释放该进程已分配的资源available[j] =work[j];}}}k--; }while(k>0);f=1;for (i=0;i<n; i++)//判断有没有进程没完成{ if (finish[i]=='F'){f=0;break; }} if (f==0) {printf("不安全状态！\n");anquan=0;} else {printf("available");printf("\n");for (i=0;i<n; i++){ printf("%2d",i);printf(" ");for(j=0;j<m; j++)printf("%2d",max[i][j]);printf(" ");for(j=0;j<m; j++)printf("%2d",allocation[i][j]);printf(" ");for(j=0;j<m; j++)printf("%2d",need[i][j]);printf(" ");for(j=0;j<m; j++){if(i>0)break;printf("%2d",available[j]);}printf("\n");}}}程序结果截图：三、实验总结：这次上机模拟了进程调度过程和解决了死锁问题，让我对短作业优先调度算法和银行家算法有了比在课堂上更深刻的认识。
用VB模拟实现短进程优先调度算法
理机是如何按调度算法去调度进程 的 本文正是模拟处理机调
度 中短 进 程 优先 （Ｐ ） Ｓ Ｆ 调度 算 法 的调 度 的过 程 。 将 课 本 上 的 抽 它
ｔ ｅｌ用 于 随 机 产 生 ５个进 程 的到 达 时 间 、 务时 问等 ｉ ｒ： ｍ 服 象描 述 转 化 成 了 动态 的演 示 ， 处 理 机 的 调 度 过 程 更 加 直 观 ． 使 能 ｔ ｅ２ 用 于填 写进 程 的处 理 情 况 。 ｉ ｒ： ｍ 引 起学 习者 的兴 趣 １ 短 进 程 优 先调 度算 法 介 绍 ： ． 短进 程 优先 调 度 （ｈ ｕｅｔ ｒ ｅｓＦｒｔ ｃ ｅｕｉｇ简 称 Ｓ ｏ ｔ ｏ ｓ ｉ ｈｄｌ ｓＰ ｃ ｓＳ ｎ Ｓ Ｆ算 法 ， 先 考虑 进 程 的服 务 时 问 ， 次 总 是 在 就 绪 队 列 中 选 Ｐ） 优 每 择 一 个 服 务 时 间最 短 的进 程 进 行 调 度 ．并将 处 理 机 分 配 给 此 进 程。 系统若采用非抢 占式调度算法 ， 则使其立 即执行并一直执行 到完成或因等待事件发生而阻塞放弃处 理机时为止 ：若采 用抢 占式 调 度 算 法 ． 果 有新 的进 程进 入 就 绪 队 列 ． 度 器 就会 被触 如 词 图 １短 进 程 优 先 调 度 算 法 运 行 界 面 发 ． 且 新进 程 的 服 务 时 间 比现行 进 程 的 剩 下 的服 务 时 间 短 ． 而 这 ４ ．源 程 序 时 正 在 执行 的进 程 会 被 中 断 ． 并 由 新 进 程 取 得 Ｃ Ｕ 的 使 用 权 。 Ｐ 在 宙体 的通 用 声 明 段 声 明 本 文实 现 的是非 抢 占式 Ｓ Ｆ调 度 算 法 Ｐ Ｄｍ ｊ ｔ ｄ ％（ ＇ｉｅｓ ｓ ｄ ｉ ％，％， ｄ ４ ｔ ｊ ｓ ） ｍ ％， ｓ ％ ％， ２用 Ｖ ． Ｂ模 拟短 进 程 优 先 调 度 算 法 的 思 路 Ｄｍ ｒ ｏｄｐ ４ Ａ ｆｐ ｉ ｃｒ ｓ （ ｓｓ ｔ ｅ ｅ ｆ） ｐｙ 用 随 机产 生 的 字 母 串代 表 进 程 ． 有 ５个 进 程 ， 个进 程 产 Ｐｒｖ ｔ ｓ ｆｙ ｅ 共 每 ｉ ａｅ１ ｐ ｐ ｌ 生时间． 长度 各 不 相 同 。 ａ ｒ ｅ ｉ ｓＩ ｔｇ ｒ ｒｉ ｔ ｖ ｍｅ Ａ ｎｅ ｅ ， ｅｖｒ ｉ ｎｅ ｅ 首 先定 义 了一 个 用户 白定 义类 型 ｓｆ ｐ ，其 中 各 成员 分 别 ｓ ｒ ｅｔｍｅ ＡｓＩ ｔｇ ｒ ｐｔ ｅ ｙ ｓａ ｔｍｅ Ａｓ ｎｅ ｅ ｔｒ ｉ ｔｇ ｒ ｔ Ｉ 代 表 每 个 进 程 的 进 程 序 列 号 ， 达 时 间 ， 务 时 间 ， 始 服 务 时 到 服 开 ｉ ｓ ｉ ＡｓＩｔｇ ｒ ｆ ｉ ｔ ｎ ｅ ｅ ｎ ｈ ｍｅ 间， 完成时间． 周转时 间以及带权周转时间。 ｔｍｏｅｔ ｅＡ ｉ￣ ｕ ｖｒ ｍ ｓ ｎ ｅ ｉ Ｓ ｑ ｕ ｖ ｒｉ Ａｓ ｎ ｌ ｍｅ Ｓ Ｃ Ｕ处 理 进 程是 从 第 一 个 进 程 开 始 的 由于 采 用 的是 非 抢 ｄ ｔｍ ｏ ｅ ｔ ｉ ｇｅ Ｐ ｅ ｎ ｎＡ ｔｎ １ ｈａ ｓＳ ｒ ｇ ｉ ５ 占式调 度 算 法 。 第 一 个 进 程 处 理 完毕 后 有 如 下几 种 情 况 ： 则 ｌ ｆ ｇＡｓＩ ｔｇ ｒ ａ ｎ ｅｅ （） 二个 进 程 没有 产 生 ， Ｃ Ｕ 处 于 等 待 状 态 。 １第 则 Ｐ Ｅ ｄＴ ｐ ｎ ｙ ｅ ｉ ｅ ｒ ａ Ｓ ｂＦ ｒ Ｌ ａ ０ （） 二个 进 程 已 经 产 生 ．但 是 第 三 个 进 程 没 有 产 生 ， Ｐ Ｐ ｖｔ ｕ ｏｍ＿ ｏ ｄ ２第 ＣＵ Ｄｍ ｉ ｉ ％ 顺 序执 行 第 二 个进 程 如 果 依 次 执 行 第 ｎ个进 程 完毕 后 ． ｎ １ 第 ＋ ｊ ｓ＝０ ｓ ：ｓ＝０ 个 进程 产 生 ． ｎ ２个 进 程 尚没 有 产 生 ． 第 ＋ 则短 进 程 则 自然演 变成 Ｆｒ ＝０Ｔ ｏｊ ｏ ４ 先 来 先 服 务 调 度算 法 ｒｅｒｓｆ） ｈ ￣￥＝ ｅｏｄｐ ｊｃｕ （． ｅｔ （） 一个进程完 毕后 ， ３第 已经 到达 两个 以上 的进 程， 比较 Ｎ ｘ ｊ 则 Ｅ ｄＳ ｂ ｎ ｕ 已 到达 的进 程 长 度 ， 择 较 短 的 进 程 去 执行 。 选
采用时间片轮转算法调度程序
采用时间片轮转算法调度程序学号：姓名：专业：指导教师：日期：目录一、需求分析 (3)1、设计要求： (3)2、解决方案： (3)二、课程设计简介 (4)1、课程设计题目 (4)2、课程设计目的 (4)3、课程设计内容 (4)4、时间安排 (4)三、概要设计 (4)1、基本原理 (4)2、算法思想设计 (5)3、数据结构及模块说明： (5)四、主要函数及其说明 (6)五、调试分析 (7)1、调试过程及步骤 (7)2、结果分析（以三个进程数为例） (8)六、总结及参考文献 (9)1、总结： (9)2、参考文献 (9)附录：程序源代码 (9)一、需求分析1、设计要求：在多道程序或多任务系统中，系统同时处于就绪状态的进程有若干个。
为了使系统中各进程能有条不紊地进行，必须选择某种调度策略，以选择一进程占用处理机。
要求用时间片轮转算法模拟单处理机调度，以巩固和加深处理机调度的概念。
2、解决方案：（1）、假设系统有5个进程，每个进程用一个进程控制块PCB来表示。
PCB包括：进程名、链接指针、到达时间、估计运行时间和进程状态。
其中，进程名即进程标识。
链接指针指出下一个到达进程的进程控制块地址，按照进程到达的顺序排队，统设置一个队头和队尾指针分别指向第一个和最后一个进程，新生成的进程放队尾。
估计运行时间：可由设计者任意指定一个时间值。
到达时间：进程创建时的系统时间或由用户指定，调度时，总是选择到达时间最早的进程。
进程状态：为简单起见，假定进程有三种状态，就绪、等待和完成，并假定进程一创建就处于就绪状态，用R表示，当一个进程运行结束时，就将其置成完成状态，用F表示。
当一个进程未运行完成并且时间片不足时，就将其置成等待状态，用W表示。
（2）、为每个进程任意确定一个要求运行时间和到达时间。
（3）、按照进程到达的先后顺序排成一个循环队列。
再设一队首指针指向第一个到达进程的首址。
（4）、执行处理机调度时，开始选择队首的第一个进程运行。
进程调度
Linux调度程序提高交互式程序的优先级，让它们运行更频繁。因此， 调度程序提供较长的默认时间片给交互式程序。此外，调度程序还能根 据进程的优先级动态调整分配给它的时间片，从而保证了优先级高的进 程，执行的频率高，执行时间长。通过动态掉正优先级和时间片的长度 机制，Linux调度性能不但非常稳定而且也很强健。
计算优先级和时间片
进程拥有一个初始的nice值(优先级)，范围是-20~19，默认 是0，进程task_struct的static_prio域存放这个值，因为它 从一开始由用户指定，不能修改，所以是静态优先级。 调度程序用到的动态优先级存放在prio域里，动态优先级 是通过一个关于静态和进程交互性的函数关系计算而来。 effective_prio()函数返回一个进程的动态优先级。 调度程序通过一些推断来获取准确反映进程时I/O消耗型还 是处理器消耗型。 为了支持这种推断，Linux记录了一个进程用于休眠和用于 执行的时间。该值存放在task_struct的sleep_avg域中，范 围是从0到MAX_SLEEP_AVG。默认值是10毫秒， sleep_avg会根据它的休眠时间的长短而增长，直到最大值 为止，进程没运行一个节拍，sleep_avg就相应减少，直到 0为止。
可运行队列
调度程序中最基本的数据结构是运行队列。 可执行队列定义于kernel/sched.c中，由结构runqueue 表示，可执行队列是给定处理器上可执行进程的链表 ，每个处理器一个。每一个可投入运行的进程都惟一 的归属于一个可执行队列。此外，可执行队列中还包 含每个处理器的调度信息。因此，可执行队列是每一 个处理器最重要的数据结构。
重新计算时间片
操作系统在所有的进程的时间片都用完时，会重新计 算每个进程的时间片。 典型的实现是循环访问每个进程： for(系统中的每个人物){ 重新计算优先级 重新计算时间片 }
进程调度
引起进程调度的主要因素有：（1）一个进程运行完毕。
（2）一个正在运行的进程被阻塞。
（3）在抢占式调度中，一个高优先级的进程被创建。
（4）在抢占式调度中，一个高优先级进程由阻塞唤醒。
（5）在轮转式调度中，正垢进程运行完进程调度的概念无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。
另外，系统进程也同样需要使用处理机。
这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。
进程有四个基本属性1.多态性从诞生、运行，直至消灭。
2.多个不同的进程可以包括相同的程序3.三种基本状态它们之间可进行转换4.并发性并发执行的进程轮流占用处理器进程的三种基本状态:1.等待态：等待某个事件的完成；2.就绪态：等待系统分配处理器以便运行；3.运行态：占有处理器正在运行。
运行态→等待态往往是由于等待外设，等待主存等资源分配或等待人工干预而引起的。
等待态→就绪态则是等待的条件已满足，只需分配到处理器后就能运行。
运行态→就绪态不是由于自身原因，而是由外界原因使运行状态的进程让出处理器，这时候就变成就绪态。
例如时间片用完，或有更高优先级的进程来抢占处理器等。
就绪态→运行态系统按某种策略选中就绪队列中的一个进程占用处理器，此时就变成了运行态进程调度的分级高级、中级和低级调度作业从提交开始直到完成，往往要经历下述三级调度：高级调度：(High-Level Scheduling)又称为作业调度，它决定把后备作业调入内存运行；低级调度：(Low-Level Scheduling)又称为进程调度，它决定把就绪队列的某进程获得CPU；中级调度：(Intermediate-Level Scheduling)又称为在虚拟存储器中引入，在内、外存对换区进行进程对换。
进程调度的方式进程调度有以下两种基本方式：非剥夺方式分派程序一旦把处理机分配给某进程后便让它一直运行下去，直到进程完成或发生某事件而阻塞时，才把处理机分配给另一个进程。
模拟进程管理课程设计
模拟进程管理课程设计一、课程目标知识目标：1. 学生能理解计算机操作系统中进程管理的基本概念，掌握进程的定义、状态及其转换过程。
2. 学生能描述进程调度算法的类型及其特点，解释不同调度算法对系统性能的影响。
3. 学生能解释进程同步与互斥的概念，并掌握基本的同步机制。
技能目标：1. 学生能够运用流程图或伪代码设计简单的进程管理策略。
2. 学生通过模拟实验，能够分析和评价不同进程调度算法的效果。
3. 学生能够通过小组合作，编写简单的进程同步程序，解决实际问题。
情感态度价值观目标：1. 学生通过本课程的学习，培养对计算机操作系统工作原理的兴趣，激发对信息技术领域的探索热情。
2. 学生在小组合作中，学会倾听、尊重他人意见，培养团队合作精神和解决问题的能力。
3. 学生能够认识到计算机科学技术对社会发展的重要性，增强对科技进步的敏感性和责任感。
课程性质分析：本课程为计算机科学领域的选修课程，旨在帮助学生深入理解计算机操作系统的核心概念，提高解决实际问题的能力。
学生特点分析：考虑到学生为高年级学生，具备一定的计算机操作基础和编程能力，对操作系统有一定了解，但需深化对进程管理的认识。
教学要求：结合学生特点和课程性质，课程目标设定既要注重理论知识的学习，也要关注实践技能的培养，同时关注学生情感态度价值观的塑造。
通过具体可衡量的学习成果，确保学生能够达到课程预期目标。
二、教学内容1. 进程管理基本概念：包括进程的定义、特征、状态及其转换，进程控制块的作用与内容。
2. 进程调度算法：研究进程调度的基本方法，如先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转等算法，分析各自优缺点。
3. 进程同步与互斥：介绍进程同步、互斥的概念，探讨同步机制如信号量、管程等，并分析经典同步问题，如生产者-消费者问题、读者-写者问题。
4. 进程通信：讲解进程间通信的方式，如消息传递、共享内存等，以及相关的通信协议。
5. 模拟实验：设计实验环节，让学生通过模拟软件或编程实践，加深对进程管理原理的理解。
CPU调度算法的模拟实现课程设计
设计 1 CPU 调度算法的模拟实现一、设计目的1、深入理解CPU调度的四种算法：先到先服务算法FCFS、非抢占最短作业优先算法SJF、可抢占优先权调度算法PRIOR、时间片轮转算法RRO2、利用程序设计语言编写算法，模拟实现先到先服务算法FCFS、非抢占最短作业优先算法SJF、可抢占优先权调度算法PRIOR、时间片轮转算法RR O3、针对模拟进程，利用CPU调度算法进行调度。
4、进行算法评价，计算平均周转时间和平均等待时间。
二、设计要求1、调度所需的进程参数由输入产生：采用手工输入参数或产生随机数的方法。
2、针对各个进程模拟算法，输出进程调度结果，包括执行算法的等待时间和周转时间。
3、根据调度结果对算法进行调试分析，纠正程序错误并对算法进行优化，总结并输出算法评价指标。
三、设计说明（含系统框图和（或）主要算法的流程图）（1）优先权调度#include "stdio.h"#include "stdlib.h"#define N 10//#define M 10typedef struct{int m;//int flag;int priority;// 优先级顺序float zhixing;float zhouzhuan;float dq_zhouzhuan;}process;//int flag=0;// 标志已经执行个进程的个数//float time=0;// 当前共执行的时间void main(){//int plag=0;float time=0;int n;int i,j,temp;process fcfs[N],*p[N],*q;float time_zhouzhuan=0,wtime_zhouzhuan=0;//输入printf(" 请输入进程的个数:");scanf("%d",&n);for(i=0;i<n;i++){fcfs[i].m=i+1;//fcfs[i].linshi=0;//fcfs[i].flag=0;Printf("请输入进程％d所需的执行时间和进程的优先级:",fcfs[i].m); scanf("%f %d",&fcfs[i].zhixing,&fcfs[i].priority);}Printf("haha");for(i=0;i<n;i++){p[i]=(process*)malloc(sizeof(process));//分配空间P[i]=&fcfs[i];}//按优先级别的排序for(j=0;j<n-1;j++){printf("ok");// 有问题temp=j;for(i=j+1;i<n;i++){printf("ky");if(p[i]->priority>p[temp]->priority)temp=i;}printf("#####");q=p[j];// 交换p[j]=p[temp];p[temp]=q;}printf("he");//优先级算法for(i=0;i<n;i++){ time+=p[i]->zhixing;p[i]->zhouzhuan=time; p[i]->dq_zhouzhuan=p[i]->zhouzhuan/p[i]->zhixing; }for(i=0;i<n;i++){time_zhouzhuan+=p[i]->zhouzhuan; wtime_zhouzhuan+=p[i]->dq_zhouzhuan;} time_zhouzhuan/=n;wtime_zhouzhuan/=n;//输出结果Printf("静态优先级算法的进程的执行顺序为:∖n");for(i=0;i<n;i++){Printf("%d ",P[i]->m);}Printf("∖n 平均周转时间为%f",time_zhouzhuan);Printf("∖n 带权平均周转时间为%f",wtime_zhouzhuan);} (2) FCFS 和SJF 综合#include "stdio.h"#define getjcb(tyPe) (tyPe*)malloc(sizeof(tyPe))#define NULL 0/* 作业 名 *//* 作 业状态 *//* 提交 时间 *//* 优先权 *//* 开始运 行时间 *//* 完成 时间 */ /* 周转时间 */ /* 带权周 转时间 */ /* 作业所需 运行时间 */ char resource[10]; /* 所需 资源 */struct jcb *link; /* 结构体指 针 */ } *p,*q,*head=NULL;typedef struct jcb JCB; inital(){ int i;printf("\nInput jcb num\n"); scanf("%d",&n);printf("Input\nname\tts\tntime\tresource\n"); for(i=0;i<n;i++){p=getjcb(JCB);scanf("%s\t%d\t%d\t%s",&p->name,&p->ts,&p->ntime,&p->resource);p->state='W';p->link=NULL;if(head==NULL) head=q=p;else{q->link=p;q=p; } }}fileinput(){int n=0,time=0;floateti,ewi; struct jcb{ charname[10]; char state; int ts; float super; int tb;int tc;float ti;float wi;int ntime;FILE *fp; int i;if((fp=fopen("os2.txt","r"))==NULL) printf(" open error!") ;fscanf(fp,"%d\n",&n);for(i=0;i<n;i++){p=getjcb(JCB); scanf(fp,"%s%d%d%s",&p->name,&p->ts,&p->ntime,&p->resource); p->state='W';p->link=NULL;if(head==NULL) head=q=p;else{q->link=p; q=p;}}fclose(fp);}void print(JCB *pr,int m){JCB *p;printf("\ntime=%d",time);if(m==3){printf("\nname\tstate\tts\tntime\tsuper\tsource\ttb\ttc\tti\twi\n");printf("%s\t%c\t%d\t%d\t%4.2f\t%s\t%d\t%d\t%4.2f\t%4.2f\n",pr->name,pr->state,pr->ts,pr->ntime,pr->super,pr->resource,pr->tb,pr->tc,pr->ti, pr->w i); }else { printf("\nname\tstate\tts\tntime\tsource\ttb\ttc\tti\twi\n");printf("%s\t%c\t%d\t%d\t%s\t%d\t%d\t%4.2f\t%4.2f\n",pr->name,pr->state,pr->ts,pr->ntime,pr->resource,pr->tb,pr->tc,pr->ti,pr->wi); }p=head;do{ if(p->state=='W')if(m==3){ printf("%s\t%c\t%d\t%d\t%4.2f\t%s\n",p->name,p->state,p->ts,p->ntime,p->super,p->resource);}else{printf("%s\t%c\t%d\t%d\t%s\n",p->name,p->state,p->ts,p->ntime,p->resource); } p=p->link;}while(p!=NULL);p=head;do{if(p->state=='F') if(m==3){printf("%s\t%c\t%d\t%d\t%4.2f\t%s\t%d\t%d\t%4.2f\t%4.2f\n",p->name,p->state,p->ts,p->ntime,p->super,p->resource,p->tb,p->tc,p->ti,p->wi);} else{printf("%s\t%c\t%d\t%d\t%s\t%d\t%d\t%4.2f\t%4.2f\n",p->name,p->state,p->ts,p->ntime,p->resource,p->tb,p->tc,p->ti,p->wi); }p=p->link;}while(p!=NULL);} void last(){eti/=n;ewi/=n;printf("\neti=%7.3f\tewi=%7.3f\n",eti,ewi);}super(){JCB *padv; padv=head; do{if(padv->state=='W'&&padv->ts<=time)padv->super=(float)(time-padv->ts+padv->ntime)/padv->ntime; padv=padv->link;}while(padv!=NULL);}void hrn(m){JCB *min;int i,iden;for(i=0;i<n;i++){p=min=head;iden=1;super();do{if(p->state=='W'&&p->ts<=time)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p;p=p->link;}while(p!=NULL);if(iden) {i--;time++;printf("\ntime=%d:\tno JCB submib...wait...",time);if(time>1000){printf("\nruntime is toolong...error...");getch();}}else{running(min,m);}}}void sjf(int m){JCB *min;int i,iden;for(i=0;i<n;i++){p=min=head;iden=1;do{ if(p->state=='W'&&p->ts<=time)if(iden){min=p;iden=0;}else if(p->ntime<min->ntime) min=p;p=p->link;}while(p!=NULL) ;if(iden) {i--;printf("\ntime=%d:\tno JCBsubmib...wait...",time);time++;if(time>100){printf("\nruntime is too long...error");getch();}} else{running(min,m);}}}fcfs(int m){int i,iden;printf("\n\nthe jcb is runing...");for(i=0;i<n;i++){p=head;iden=1;do{ if(p->state=='W'&&p->ts<=time) iden=0;if(iden)p=p->link;}while(p!=NULL&&iden) ;if(iden) {i--;printf("\ntime=%d:\tno JCB submib...wait...",time);time++;if(time>100){printf("\nruntime is too long...error");getch();}} else{ running(p,m);}}}running(JCB *p,int m){p->tb=time;p->state='R';p->tc=p->tb+p->ntime;p->ti=(float)(p->tc-p->ts);p->wi=(float)(p->ti/p->ntime);eti+=p->ti;ewi+=p->wi;print(p,m);time+=p->ntime;p->state='F';printf("\n%s has been finished!\npress any keyto continue...\n",p->name);getch();}void runjcb(int m){printf("\n\nstart running jcb...");switch(m){case 1:fcfs(m);break;case 2:sjf(m);break;case 3:hrn(m);break;default:printf("\nrunjcb error...\n");exit();}}fileway(){printf("\nadopts the file way to input the datas...y/n:") ;if(getch()=='y') fileinput(); else inital();} start(){int m;char str[100]="\nselect algorithm\n1.FCFS\n2.SJF\n3.HRN\n" ;printf("%s",str);m=getch()-48; fileway();if(1<=m&&m<=3) runjcb(m);else {printf("\nselect error!try again...\n");start();} last();}void main(){ start();printf("\nfinished!");getch();}(3)RR 算法#include<stdio.h> #include<stdlib.h> #include<conio.h> #include<iostream> using namespace std;#define getch(type)(type*)malloc(sizeof(type))#define null 0#define MAXN 1000int stack[MAXN];int top;StruCtPcb{∕/调用进程模块Char name[10];//进程名char State; /进/ 程状态：就绪，运行，完成int super; //进程优先级int ntime;// 需要运行的时间int rtime;// 到达时间changestruct pcb* link;// 链接指针}*ready=null,*p;typedef struct pcb PCB;void destroy();void check();VOid SOrtO//建立对进程优先级排列函数{PCB *first,*secOnd;int insert = 0;if( ( ready == null ) || ( ( p -> rtime ) < ( ready -> rtime ) ) ){// 优先级最大者，插入队首p -> link = ready;ready = p;}else {//进程比较优先级。
进程的调度算法
进程的调度算法调度算法的实质是：根据系统的资源分配策略所规定的资源分配算法。
先介绍⼀下进程调度与作业调度的区别：进程调度是真正让某个就绪状态的进程到处理机上运⾏，⽽作业调度只是使作业具有了竞争处理机的机会。
进程调度（⼜称微观调度、低级调度、短程调度）：是按照某种调度算法从就绪状态的进程中选择⼀个进程到处理机上运⾏。
负责进程调度功能的内核程序称为进程调度程序。
作业调度（⼜称⾼级调度、宏观调度、长程调度）：是按某种调度算法从后备作业队列中选择作业装⼊内存运⾏；另外当该作业执⾏完毕后，还负责回收系统资源。
完成作业调度功能的程序称为作业调度程序。
下⾯介绍⼏种常见的调度算法:先来先服务(FCFS，first come first served)FCFS调度算法是⼀种最简单的调度算法，该调度算法既可以⽤于作业调度也可以⽤于进程调度。
在作业调度中，算法每次从后备作业队列中选择最先进⼊该队列的⼀个或⼏个作业，将它们调⼊内存，分配必要的资源，创建进程并放⼊就绪队列。
在进程调度中，FCFS调度算法每次从就绪队列中选择最先进⼊该队列的进程，将处理机分配给它，使之投⼊运⾏，直到完成或因某种原因⽽阻塞时才释放处理机。
优点：保证了公平性，规则简单缺点:有利于长进程⽽不利于短进程，有利于CPU 繁忙的进程，⽽不利于I/O 繁忙的进程短作业优先(SJF，Shortest Job First)短作业（进程）优先调度算法是指对短作业（进程）优先调度的算法。
短作业优先(SJF)调度算法是从后备队列中选择⼀个或若⼲个估计运⾏时间最短的作业，将它们调⼊内存运⾏。
⽽短进程优先(SPF)调度算法，则是从就绪队列中选择⼀个估计运⾏时间最短的进程，将处理机分配给它，使之⽴即执⾏，直到完成或发⽣某事件⽽阻塞时，才释放处理机。
优点：相⽐FCFS 算法，该算法可改善平均周转时间和平均带权周转时间，缩短进程的等待时间，提⾼系统的吞吐量。
缺点：该算法对长作业不利，SJF调度算法中长作业的周转时间会增加。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
进程调度模拟程序
一、引言
进程调度是操作系统中的重要组成部分，它负责决定哪个进程能够获得CPU
的使用权，以及何时、多久获得。
进程调度算法的设计直接影响到系统的性能和效率。
为了评估和比较不同调度算法的性能，我们需要进行进程调度模拟程序的开发。
二、背景
在操作系统中，进程调度是为了合理、高效地利用CPU资源，提高系统的吞
吐量和响应时间。
进程调度算法的选择和实现需要考虑多个因素，如进程的优先级、进程的等待时间、进程的执行时间等。
为了更好地理解和评估不同的调度算法，我们需要开发一个进程调度模拟程序。
三、目的
本文档的目的是详细描述进程调度模拟程序的标准格式，包括程序的输入、输出、功能和实现细节。
通过本文档，读者将了解到如何使用该模拟程序进行不同进程调度算法的模拟，并根据模拟结果评估不同算法的性能。
四、程序输入
1. 进程信息：模拟程序需要输入一组进程信息，包括进程ID、到达时间、执
行时间和优先级等。
可以通过读取文件或手动输入的方式提供进程信息。
2. 调度算法选择：模拟程序需要用户选择要使用的调度算法，如先来先服务（FCFS）、最短作业优先（SJF）、优先级调度等。
3. 其他参数设置：模拟程序可能需要用户设置其他参数，如时间片大小（对于
时间片轮转调度算法）、优先级范围等。
五、程序输出
1. 进程调度顺序：模拟程序将输出进程按照调度算法执行的顺序，包括进程ID和执行时间等。
2. 平均等待时间：模拟程序将输出平均等待时间，用于评估调度算法的性能。
3. 其他评价指标：根据具体的调度算法，模拟程序可能还输出其他评价指标，如响应时间、周转时间等。
六、程序功能
1. 进程调度模拟：模拟程序根据输入的进程信息和调度算法，模拟执行进程调度过程，并输出调度结果。
2. 性能评估：模拟程序根据调度结果，计算出各种评价指标，用于评估不同调度算法的性能。
七、实现细节
1. 数据结构：模拟程序可以使用适当的数据结构来表示进程信息和调度队列，如数组、链表、优先队列等。
2. 调度算法实现：根据选择的调度算法，模拟程序需要实现相应的调度逻辑，如FCFS、SJF、优先级调度等。
3. 算法评估：模拟程序需要计算和输出各种评价指标，如平均等待时间、响应时间、周转时间等。
4. 用户界面：模拟程序可以提供用户友好的界面，包括输入界面、结果展示界面等。
八、总结
本文档详细描述了进程调度模拟程序的标准格式，包括程序的输入、输出、功能和实现细节。
通过该模拟程序，用户可以模拟不同的进程调度算法，并评估其性能。
进程调度模拟程序的开发对于理解和比较不同调度算法的性能具有重要意义。