时间片轮转算法性能指标

⑴ 软考嵌入式系统设计师考什么

软考嵌入式系统设计师，包含两个考试科目：基础知识与应用技术；基础知识科目在上午考试，应用技术科目在下午考试。软考嵌入式系统设计师各科目考试内容有所不同。
根据软考嵌入式系统设计师考试大纲，各科目考试范围如下：
考试科目1：嵌入式系统基础知识
1.计算机科学基础
1.1数制及转换
·二进制、八进制、十进制和十六进制等常用数制及其相互转换
1.2数据的表示
·数的机内表示（原码、反码、补码、移码，定点和浮点，精度和溢出）
·字符、汉字、声音、图像的编码方式
·校验方法和校验码（奇偶验码、海明校验码、循环校验码）
1.3算术和逻辑运算
·计算机中的二进制数运算方法
·逻辑代数的基本运算和逻辑表达式的化简
1.4计算机系统结构和重要部件的基本工作原理
· CPU和存储器的组成、性能、基本工作原理
·常用I/O设备、通信设备的性能，以及基本工作原理
·I/O接口的功能、类型和特点
·虚拟存储存储基本工作原理，多级存储体系
1.5安全性、可靠性与系统性能评测基础知识
·诊断与容错
·系统可靠性分析评价
·计算机系统性能评测方法
2.嵌入式系统硬件知识
2.1数字电路和逻辑电路基础
2.1.1组合电路和时序电路
2.1.2总线电路与电平转换电路
2.1.3可编程逻辑器件
2.2嵌入式微处理器基础
2.2.1嵌入式微处理器体系结构
·冯·诺伊曼结构与哈佛结构
· CISC与RISC
·流水线技术
·信息存储的字节顺序（大端存储法和小端存储法）
2.2.2嵌入式系统处理器的结构和类型
·常用8位处理器的体系结构和类型
·常用16位处理器的体系结构特点
·常用32位处理器的体系结构特点
·常用DSP处理器的体系结构特点
·多核处理器的体系结构特点
2.2.3异常
·同步异常（陷阱、故障、终止）
·异步异常（中断）
·可屏蔽中断、不可屏蔽中断
·中断优先级、中断嵌套
2.3嵌入式系统的存储体系
2.3.1存储器系统
·存储器系统的层次结构
·高速缓存（Cache）
·内存管理单元（MMU）
2.3.2 ROM的种类与选型
·常见ROM的种类
· PROM、EPROM、E2PROM型ROM的典型特征和不同点
2.3.3 Flash Memory的种类与选型
· Flash Memory的种类
· NOR和NAND型Flash Memory的典型特征和不同点
2.3.4 RAM的种类与选型
·常见RAM的种类
· SRAM、DRAM、DDRAM、NVRAM的典型特征和不同点
2.3.5外存
·常见外存的种类
·磁盘、光盘、CF、SD等的典型特征和不同点
2.4嵌入式系统I/O接口
2.4.1定时器和计数器基本原理与结构
2.4.2 GPIO、PWM接口基本原理与结构
2.4.3 A/D、D/A接口基本原理与结构
2.4.4键盘、显示、触摸屏接口基本与结构
2.4.5嵌入式系统音频接口
2.5嵌入系统通信及网络接口
· PCI、USB、串口、红外、并口、SPI、IIC、PCMCIA的基本原理与结构
·以太网、CAN、WLAN、蓝牙、1394的基本原理与结构
2.6嵌入式系统电源分类及电源原理
2.7电子电路设计
2.7.1电子电路设计基础知识
·电子电路设计原理
·电子电路设计方法及步骤
·电子电路设计中的可靠知识
2.7.2 PCB设计基础知识
· PCB设计原理
· PCB设计方法及步骤
·多层PCB设计的注意事项及布线原则
· PCB设计中的可靠性知识
2.7.3电子电路测试基础知识
·电子电路测试原理与方法
·硬件抗干扰测试
3.嵌入式系统软件知识
3.1嵌入式软件基础知识
3.1.1嵌入式软件的分类（系统软件、支撑软件、应用软件）
3.1.2无操作系统支持的嵌入式软件体系结构（轮询、中断、前后台）
3.1.3有操作系统支持的嵌入式软件体系结构
3.1.4板极支持包基础知识（系统初始化、设备驱动程序）
3.1.5嵌入式中间件（GUI、数据库）
3.2嵌入式操作系统基础知识
3.2.1嵌入式操作系统体系结构
·单体结构、分层结构和微内核结构
3.2.2任务管理
·多道程序技术
·进程、线程、任务的概念
·任务的实现（任务的层次结构、任务控制块、任务的状态及状态转换、任务队列）
·任务调度（调度算法的性能指标、可抢占调度、不可抢占调度、先来先服务、短作业优先算法、时间片轮转算法、优先级算法）
·实时系统及任务调度（RMS、EDF算法）
·任务间通信（共享内存、消息、管道、信号）
·同步与互斥（竞争条件、临界区、互斥、信号量、死锁）
3.2.3存储管理
· Flat存储管理方式
·分区存储管理（固定分区、可变分区）
·地址重定位（逻辑地址、物理地址、地址映射）
·页式存储管理
·虚拟存储技术（程序局部性原理、虚拟页式存储管理、页面置换算法、工作集模型）
3.2.4设备管理
·设备无关性、I/O地址、I/O控制、中断处理、缓冲技术、假脱机技术）
3.2.5文件系统基础知识
·文件和目录
·文件的结构和组织
·存取方法、存取控制
·常见嵌入式文件系统（FAT、JFFS、YAFFS）
3.2.6操作系统移植基础知识
3.3嵌入式系统程序设计
3.3.1嵌入式软件开发基础知识
3.3.2嵌入式程序设计语言
·汇编、编译、解释系统的基础知识和基本工作原理
·汇编语言
·基于过程的语言（过程/函数、参数传递、全局变量、递归、动态内存分配、数据类型）
·面向对象的语言（对象、数据抽象、继承、多态、自动内存管理）
·各类程序设计语言的主要特点和适用情况
3.3.3嵌入式软件开发环境
·宿主机、目标机
·编辑器、编译器、链接器、调试器、模拟器
·常用嵌入式开发工具（编程器、硬件仿真器、逻辑分析仪、示波器）
·集成开发环境
·开发辅助工具
3.3.4嵌入式软件开发
·软件设计（模块结构设计、数据结构设计、内存布局、面向对象的分析与设计）
·嵌入式引导程序的设计、设备驱动程序设计、内核设计、网络程序设计、应用软件设计）
·编码（编程规范、代码审查）
·测试（测试环境、测试用例、测试方法、测试工具）
·下载和运行
3.3.5嵌入式应用软件移植
4.嵌入式系统的开发与维护知识
4.1系统开发过程及其项目管理
·系统开发生命周期各阶段的目标和任务的划分方法
·系统开发项目挂你基础知识及其常用管理工具使用方法
·主要的系统开发方法
·系统开发工具与环境知识
4.2系统分析基础知识
·系统分析的目的和任务
·系统分析方法
·系统规格说明书的编写方法
4.3系统设计知识
·传统系统设计方法
·软硬件协同设计方法
4.4系统实施知识
·系统架构设计
·系统详细设计
·系统调试技术
·系统测试
4.5系统维护知识
·系统运行管理知识
·系统维护知识
·系统评价知识
5.安全性知识
·安全性基本概念
·加密与解密机制
6.标准化知识
·标准化的概念
·国际标准、标准、行业标准、企业标准基本知识
·代码标准、文件格式标准、安全标准、软件开发规范和文档标准知识
·标准化机构
·嵌入式系统相关标准
7.信息化基础知识
·信息化和信息系统基本概念
·有关的法律、法规
8.嵌入式技术发展趋势
9.计算机专业英语
·正确阅读和理解相关领域的英文资料
考试科目2：嵌入式系统设计应用技术
1.嵌入式系统开发过程
1.1系统需求分析方法与步骤
1.2系统设计
·系统硬件配置
·系统功能组成分配
·软硬件功能的分配
·可行性验证及设计审查
·系统规格
·周期，成本及工作量估计
·开发计划
1.3软硬件协同设计
1.4硬件设计
1.5软件设计
·软件结构
·设计评审
·软件详细设计
1.6系统测试
·测试环境
·测试计划（内容、方法、标准、过程、检验）
·硬件测试
·软件测试（单元测试、集成测试）
·软硬件联合测试
·实施测试
1.7系统评估
1.8软件维护
2.嵌入式系统硬件设计
2.1嵌入式系统硬件基本结构
2.1.1嵌入式微处理结构与应用
2.1.2异常及中断处理技术
2.1.3 DMA技术
2.1.4多处理系统
·多处理器系统特点
·多处理器系统构建技术
2.1.5总线架构
·应用系统中的总线配置
2.1.6内存种类及架构
·存储器系统接口设计
2.1.7数字电路和逻辑电路
·专用集成电路
·可编程逻辑控制器件
2.2输入/输出接口设计
2.2.1输入/输出接口
·接口信号电平转换
·接口驱动电路设计
2.2.2输入/输出接口应用技术
·外围设备
·串口通信
·并口通信
·模拟接口
·通信接口设备
·通信标准和协议
·数据传输方式
2.3外围设备接口应用技术
2.3.1外围存储设备
·存储卡，记忆棒，IC卡，MMC卡，SD卡
· DVD、CD-R、CD-RW
2.3.2外围输入/输出设备
·键盘，鼠标，触摸屏
·液晶板、LED、7段数码管、蜂鸣器
2.3.3电源设计技术
2.4可靠性与安全性设计技术
2.4.1错误检测与隔离技术
2.4.2冗余设计
2.4.3系统恢复设计
2.4.4诊断技术
2.4.5常用安全标准
2.4.6抗干扰设计
2.4.7电磁兼容设计
2.4.8系统加密
3.嵌入式系统软件设计
3.1嵌入式系统软件结构设计
3.2嵌入式操作系统应用技术
3.2.1时间管理
·系统时间
·时钟中断
3.2.2内存管理
·静态内存管理
·动态内存管理
3.2.3任务管理和任务间的通信
·任务间的通信机制
·信号量
·邮箱
·消息队列
3.2.4异常处理
·异常处理方法
·中断优先级处理方法
·系统调用
3.2.5嵌入式文件系统应用技术
3.2.6嵌入式系统图形用户接口（GUI）应用技术
3.2.7嵌入式系统数据库应用技术
3.3嵌入式软件设计技术
3.3.1汇编语言设计
·数据类型
·汇编语言程序结构
·汇编语言程序设计及优化
·子程序调用
3.3.2嵌入式C语言设计
· ANSI-C的数据类型
· C程序结构
· C语言程序设计及优化
·程序的编译与链接
3.3.3面向对象程序设计与开发
·面向对象的分析与设计方法UML
·面向对象的编程语言
·使用C++进行嵌入式系统开发
·使用Java进行嵌入式系统开发
3.4系统级软件设计技术
·嵌入式系统固件与系统初始化设计
·设备驱动程序设计
·硬件抽象层、板级支持包设计
·嵌入式软件的移植技术
4.嵌入式系统开发技术
4.1系统开发环境
4.1.1开发工具
·文本编辑器
·汇编、编译和连接程序
· ICE和ICE监控器
·配置管理工具
·逆工程工具
4.1.2平台
·操作系统
·分布式开发环境
4.1.3开发环境创建方法及评估
·开发工作分析
·开发环境的建立
·维护、管理、使用开发环境的方法
·开发环境的平测
4.2实时系统的分析技术
4.2.1实时系统的分析技术
·结构化分析方法
·面向对象分析方法
4.2.2实时系统的设计技术
·结构化分析方法
·面向对象分析方法
4.3硬件设计环境
4.3.1硬件描述语言
·硬件开发设计过程
·硬件描述语言的种类与特点
4.3.2仿真技术
·逻辑仿真方法
·逻辑仿真工具
4.3.3大规模集成电路系统的开发方法
· ASIC开发方法
· FPGA设计方法
· IP（intellectual property）
4.4协同设计
·软硬件任务工和切调
·设计平审
4.5嵌入式系统低功耗设计技术
·低功耗系统工作机制
·低功耗系统模型结构
·低功耗的硬件设计技术
·低功耗的软件设计技术
4.6分布式嵌入系统设计
·分布式系统设计原理
·分布式系统的通信技术
·分布式系统设计应用
5.嵌入式系统应用
5.1嵌入式系统在控制领域中的应用
5.2嵌入式系统在手持设备中的应用
5.3嵌入式系统在模式识别中的应用

温馨提示：因考试政策、内容不断变化与调整，猎考网提供的以上信息仅供参考，如有异议，请考生以权威部门公布的内容为准！
下方免费复习资料内容介绍：2018下半年软件设计师真题PDF
格式：ZIP大小：1151.75KB 2022下半年信息系统项目管理师知识点口诀
格式：DO大小：55.11KB
资格考试有疑问、不知道如何总结考点内容、不清楚报考考试当地政策，点击底部咨询猎考网，免费领取复习资料

⑵ 操作系统中关于时间片轮转调度算法！大家帮解答下！

时间片第一级1s，第二级2s，第三级4s...优先级第一级>第二级>第三级...首先A进入第一级执行1s，进入第二级，由于此时B还没有到达，所以A在第二级执行2s，完成，此时是第3s。B第2s已进入第一级，此时回到第一级B执行1s进入第二级，4s的时候c进入第一级，C执行1s进入第二级排在B的后面。此时候为5S，D没有到达，第一级没有进程，所以第二级B执行2S，进入第三级，此时为7S，D已进入第一级，D执行一S，转入第二级排在C后面，8S，E进入第一级，执行一S，进入第二级，排在D后面。第一级没有进程，第二级的C执行2S，进入第三级，D执行2s进入第三级，E执行1S完成，此时是14S。第二级没有进程，由第三级的D开始，执行3S完成，此时是17S，C执行1S完成，此时是18S，D执行2S完成，此时是20S。所以答案是，3，17，18，20，14

⑶ 时间片轮转调度算法的算法

多级反馈队列调度算法
(1) 设置多个就绪队列,并为各个队列赋予不同的优先级. 第一个队列的优先级最高,第二个队列次之,其余各队列的优先权逐个降低.
该算法赋予各个队列中进程执行时间片的大小也各不相同:
在优先权愈高的队列中,为每个进程所规定的执行时间片就愈小.
例如:第二个队列的时间片要比第一个队列的时间片长一倍,……,第i+1个队列的时间片要比第i个队列的时间片长一倍.
(2) 当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度.当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行;如果它在第二队列中运行一个时间片后仍未完成,再依次将它放入第三队列,……,如此下去,当一个长作业(进程)从第一队列依次降到第n队列后,在第n队列中便采取按时间片轮转的方式运行.
(3) 仅当第一队列空闲时,调度程序才调度第二队列中的进程运行; 仅当第1~(i-1) 队列均空时,才会调度第i队列中的进程运行.如果处理机正在第i队列中为某进程服务时,又有新进程进入优先权较高的队列(第1~(i-1)中的任何一个队列),则此时新进程将抢占正在运行进程的处理机,即由调度程序把正在运行的进程放回到第i队列的末尾,把处理机分配给新到的高优先权进程.?
性能
(1)终端型作业用户
(2) 短批处理作业用户
(3) 长批处理作业用户
满足了多数用户的需求 优先权调度算法
1,优先权调度算法的类型
非抢占式优先权算法
在这种方式下,系统一旦把处理机分配给就绪队列中优先权最高的进程后,该进程便一直执行下去,直至完成; 或因发生某事件使该进程放弃处理机时,系统方可再将处理机重新分配给另一优先权最高的进程.这种调度算法主要用于批处理系统中;也可用于某些对实时性要求不严的实时系统中.
抢占式优先权调度算法
系统同样把处理机分配给优先权最高的进程,使之执行.但在其执行期间,只要又出现了另一个其优先权更高的进程,进程调度程序就立即停止当前进程(原优先权最高的进程)的执行,重新将处理机分配给新到的优先权最高的进程.
这种抢占式的优先权调度算法,能更好地满足紧迫作业的要求,常用于要求比较严格的实时系统中, 以及对性能要求较高的批处理和分时系统中.
2,优先权的类型
(1) 静态优先权
静态优先权是在创建进程时确定的,且在进程的整个运行期间保持不变.
一般地,优先权是利用某一范围内的一个整数来表示的,例如,0~7或0~255中的某一整数, 又把该整数称为优先数.只是具体用法各异:有的系统用0表示最高优先权,当数值愈大时,其优先权愈低;而有的系统恰恰相反.
确定进程优先权的依据有如下三个方面:
1.进程类型.(系统进程/用户进程)
2.进程对资源的需求.(需求量的大小)
3.用户要求.(用户进程紧迫程度)
(2) 动态优先权
动态优先权是指在创建进程时所赋予的优先权,可以随进程的推进或随其等待时间的增加而改变的,以便获得更好的调度性能.
例如,我们可以规定,在就绪队列中的进程,随其等待时间的增长,其优先权以速率a提高.若所有的进程都具有相同的优先权初值,则显然是最先进入就绪队列的进程,将因其动态优先权变得最高而优先获得处理机,此即FCFS算法.
优先权的变化规律可描述为:
由于等待时间与服务时间之和,就是系统对该作业的响应时间,故该优先权又相当于响应比RP.据此,又可表示为:
3,高响应比优先调度算法
由上面的式子可以得到以下结论:
(1) 如果作业的等待时间相同,则要求服务的时间愈短,其优先权愈高,因而该算法有利于短作业.
(2) 当要求服务的时间相同时,作业的优先权决定于其等待时间,等待时间愈长,其优先权愈高,因而它实现的是先来先服务.
(3) 对于长作业,作业的优先级可以随等待时间的增加而提高,当其等待时间足够长时,其优先级便可升到很高, 从而也可获得处理机.
该算法照顾了短作业,且不会使长作业长期得不到服务 1. 非抢占式调度算法
为每一个被控对象建立一个实时任务并将它们排列成一轮转队列,调度程序每次选择队列中的第一个任务投入运行.该任务完成后便把它挂在轮转队列的队尾等待下次调度运行.
2. 非抢占式优先调度算法.
实时任务到达时,把他们安排在就绪队列的对首,等待当前任务自我终止或运行完成后才能被调度执行.
3. 抢占式调度算法
1）基于时钟中断的抢占式优先权调度算法.
实时任务到达后,如果该任务的优先级别高于当前任务的优先级并不立即抢占当前任务的处理机,而是等到时钟中断到来时,调度程序才剥夺当前任务的执行,将处理机分配给新到的高优先权任务.
2）立即抢占的优先权调度算法.
在这种调度策略中,要求操作系统具有快速响应外部时间中断的能力.一旦出现外部中断,只要当前任务未处于临界区便立即剥夺当前任务的执行,把处理机分配给请求中断的紧迫任务，实时进程调度，实时进程抢占当前。 1 实现实时调度的基本条件
1-1. 提供必要的信息-就绪时间.
1-2. 开始截止时间和完成截止时间.
1-3. 处理时间.
1-4. 资源要求.
1-5. 优先级.
2. 系统处理能力强
在实时系统中,通常都有着多个实时任务.若处理机的处理能力不够强,则有可能因处理机忙不过来而使某些实时任务不能得到及时处理, 从而导致发生难以预料的后果.假定系统中有m个周期性的硬实时任务,它们的处理时间可表示为Ci,周期时间表示为Pi,则在单处理机情况下,系统可调度必须满足下面的限制条件:
当系统不可调度时解决的方法是提高系统的处理能力,其途径有二:
其一仍是采用单处理机系统,但须增强其处理能力, 以显着地减少对每一个任务的处理时间;
其二是采用多处理机系统.假定系统中的处理机数为N,则应将上述的限制条件改为:
3. 采用抢占式调度机制
当一个优先权更高的任务到达时,允许将当前任务暂时挂起,而令高优先权任务立即投入运行.采用这种方式去满足那些开始截止时间即将到来的任务.?
4. 具有快速切换机制
应具有的能力:
(1) 对外部中断的快速响应能力.为使在紧迫的外部事件请求中断时系统能及时响应,要求系统具有快速硬件中断机构,还应使禁止中断的时间间隔尽量短,以免耽误时机(其它紧迫任务).?
(2) 快速的任务分派能力.在完成任务调度后,便应进行任务切换.为了提高分派程序进行任务切换时的速度, 应使系统中的每个运行功能单位适当的小,以减少任务切换的时间开销.实时调度实例
一, 最早截止时间优先算法(EDF)
EDF算法用于非抢占调度方式
优先级:根据任务的开始截止时间来确定任务的优先级.
二,最低松弛优先算法(LLF)
例如:系统中有两个周期性实时任务A和B,任务A要求每20ms执行一次,执行时间为10ms;任务B要求每50ms执行一次,执行时间为25ms.这样可知A和B每次必须完成的时间和开始截止时间如图所示
优先级:根据任务紧急程度来确定任务优先级
A和B任务每次必须完成的时间
A1 (10) A2 (30) A3(50) A4 (70) A5(90) A6 (110) A7(130) A8(150)
0 、10、 20、 30 、40、 50 、60、 70、 80 、90 、100 、110、 120、130、 140、 150
B1(25) B2(75) B3(125)
A和B任务每次必须开始的时间
时间(ms) A截止时间 B截止时间 调度对象
0 A1(10) B1(25) A1
10 A2(20) B1(15) B1
30 A2(0) B1(15) A2
40 A3(10) B1(5) B1
45 A3(5) B2(30) A3
55 A4(15) B2(20) B2
70 A4(0) B2(20) A4
松弛度
松弛度
( 20-10-0 ) ( 50-25-0 )
(40-10-10 ) ( 50-25-10 )
(40-10-30) (50-5-30)
(60-10-40) (50-5-40)
(60-10-45) (100-25-45)
(80-10-55) (100-25-55)
(80-10-70) (100-10-70 )
3.4.1 多处理器系统的类型
(1) 紧密耦合(Tightly Coupted)MPS.
这通常是通过高速总线或高速交叉开关,来实现多个处理器之间的互连的.它们共享主存储器系统和I/O设备,并要求将主存储器划分为若干个能独立访问的存储器模块,以便多个处理机能同时对主存进行访问.系统中的所有资源和进程,都由操作系统实施统一的控制和管理.
3.4 多处理机系统中的调度
从处理器之间耦合的紧密程度上划分:
松散耦合(Loosely Coupled)MPS.
在松散耦合MPS中,通常是通过通道或通信线路,来实现多台计算机之间的互连.每台计算机都有自己的存储器和I/O设备,并配置了OS来管理本地资源和在本地运行的进程.因此,每一台计算机都能独立地工作, 必要时可通过通信线路与其它计算机交换信息,以及协调它们之间的工作.
根据系统中所用处理器的相同与否划分:
(1) 对称多处理器系统SMPS. 在系统中所包含的各处理器单元,在功能和结构上都是相同的,当前的绝大多数MPS都属于SMP系统.例如,IBM公司的SR/6000 Model F50, 便是利用4片Power PC处理器构成的.?
(2) 非对称多处理器系统.在系统中有多种类型的处理单元,它们的功能和结构各不相同,其中只有一个主处理器,有多个从处理器：
1. 对称多处理器系统中的进程分配方式
在SMP系统中,所有的处理器都是相同的,因而可把所有的处理器作为一个处理器池(Processor pool),由调度程序或基于处理器的请求,将任何一个进程分配给池中的任何一个处理器去处理.在进行进程分配时,可采用以下两种方式之一.
1) 静态分配(Static Assigenment)方式
2) 动态分配(Dynamic Assgement)方式?
3.4.2 进程分配方式
静态分配(Static Assigenment)方式
一个进程从开始执行直到完成,都被固定分配到一个处理器上去执行.
2) 动态分配(Dynamic Assgement)方式
系统中设置有公共的就绪队列.分配进程时,可以将进程分配到任何一个处理器上.
动态分配方式的主要优点是消除了各处理器忙闲不均的现象
2. 非对称MPS中的进程分配方式?
对于非对称MPS,其OS大多采用主—从(Master-Slave)式OS,即OS的核心部分驻留在一台主机上(Master),而从机(Slave)上只是用户程序,进程调度只由主机执行.每当从机空闲时,便向主机发送一索求进程的信号,然后,便等待主机为它分配进程.在主机中保持有一个就绪队列,只要就绪队列不空,主机便从其队首摘下一进程分配给请求的从机.从机接收到分配的进程后便运行该进程,该进程结束后从机又向主机发出请求.
缺点:对主机要求高,出现故障导致整个系统瘫痪
1. 自调度(Self-Scheling)方式
1) 自调度机制?
在系统中设置有一个公共的进程或线程就绪队列, 所有的处理器在空闲时,都可自己到该队列中取得一进程(或线程)来运行.在自调度方式中,可采用在单处理机环境下所用的调度算法,如先来先服务(FCFS)调度算法,最高优先权优先(FPF)调度算法和抢占式最高优先权优先调度算法等.
3.4.3 进程(线程)调度方式
2) 自调度方式的优点?
1,系统中的公共就绪队列可按照单处理机系统中所采用的各种方式加以组织;其调度算法也可沿用单处理机系统所用的算法,即很容易将单处理机环境下的调度机制移植到多处理机系统中
2,只要系统中有任务(公共就绪队列不空)就不会出现处理机空闲的情况,也不会发生处理器忙闲不均的现象,因而有利于提高处理器的利用率.
3)自调度方式的缺点
3.4.4进程调度过程
1、进程名：作为进程的标识。
指针：进程按顺序排成循环链表，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针指出第一个进程的进程控制块首地址。
2、要求运行时间：假设进程需要运行的单位时间数。
已运行时间：假设进程已经运行的单位时间数，初值为0。
状态：可假设有两种状态，就绪状态和结束状态。进程的初始状态都为就绪状态。
3、每次运行所设计的处理器调度程序调度进程之前，为每个进程任意确定它的要求运行时间。
4、此程序是模拟处理器调度，因此，被选中的进程并不实际启动运行，而是执行
已运行时间+1
来模拟进程的一次运行，表示进程已经运行过一个单位时间。
.5、在所设计的程序中应有显示或打印语句，能显示或打印每次被选中的进程名以及运行一次后进程队列的变化。
6、为进程任意确定要求运行时间，运行所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
7、设有一个就绪队列，就绪进程按优先数（优先数范围0－100）由小到大排列（优先数越小，级别越高）。当某一进程运行完一个时间片后，其优先级应下调（如优先数加2或3）。
8、例如一组进程如下表： 进程名 A B C D E F G H J K L M 到达时间 0 1 2 3 6 8 12 12 12 18 25 25 服务时间 6 4 10 5 1 2 5 10 4 3 15 8

⑷ 模拟短作业优先算法、时间片轮转算法（RR）和优先数算法的执行情况

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#define LENsizeof(struct job)

struct job
{
char name[2];
int cometime;
int runtime;
int priority;
int finishtime;
int state;
struct job *next;
};

void readtxt();
void SJF();
void (structjob *,struct job *);
void RR(int);
void FPF();
void print1(structjob *);
void print2(structjob *);

int n=0;
struct job*head=NULL;
struct job*end=NULL;
FILE*fp=NULL;

void main()
{
if((fp=fopen("JOB1.txt","rb"))==NULL){
printf("can not find file\n");
exit(0);
}
while(!feof(fp)){
readtxt();
}
fclose(fp);

int x,y;
printf("请选择进程调度算法：\n");
printf("1.短作业优先算法 2.时间片轮转算法 3.优先数算法\n");
printf("选择序号：");
scanf("%d",&x);
if((x!=1)&&(x!=2)&&(x!=3))printf("序号不存在！\n");
else{
switch(x){
case 1: SJF(); break;
case 2: {
printf("输入时间片：");
scanf("%d",&y);
RR(y);
break;
}
case 3: FPF(); break;
}
}
}

void readtxt(){
struct job *p1;
p1=(struct job *)malloc(LEN);
fscanf(fp,"%s %d %d%d",(*p1).name,&((*p1).cometime),&((*p1).runtime),&((*p1).priority));
(*p1).state=0;
(*p1).finishtime=0;
if(n==0){
head=p1;
end=p1;
(*end).next=NULL;
n++;
}
else{
(*end).next=p1;
end=p1;
(*end).next=NULL;
n++;
}
}

void SJF(){
struct job *shead,*send,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).runtime<(*p1).runtime)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
shead=p;
send=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).runtime<(*p1).runtime)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*send).next=p;
send=p;
}
(*send).next=NULL;
printf("%s\n","短作业优先算法执行结果：");
printf("%s\n","进程执行顺序 周转时间");
print1(shead);
}

void RR(intpertime){
structjob *rhead,*rend,*rrhead,*rrend,*p1,*p2,*p;
int i,curtime=0,m=0,temp1=0,temp2;
while(m!=n){
p1=head;
temp2=temp1;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).runtime!=0)&&((*p1).state!=1)){temp1++;break;}
else p1=(*p1).next;
}
if(p1!=NULL){
p2=(*p1).next;
for(i=i+1;i<n;i++){
if((((*p2).cometime<(*p1).cometime)&&((*p2).runtime!=0)&&((*p2).state!=1))||
(((*p2).cometime==(*p1).cometime)&&((*p2).priority<(*p1).priority)&&((*p2).runtime!=0)&&((*p2).state!=1)))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
}

if(temp2!=temp1){
(*p1).state=1;
p=(struct job *)malloc(LEN);
(p,p1);
if(temp1==1) {rhead=p;rend=p;}
else{
(*rend).next=p;
rend=(*rend).next;
}
}
else{
if((temp1==1)&&(m==0)){
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
}
p=(struct job *)malloc(LEN);
(p,rhead);
rrhead=p;
rrend=p;
}
else{
if(strcmp((*rhead).name,(*rrend).name)==0){
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}

}
else{
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}
}
}
}
}
(*rrend).next=NULL;
printf("%s%d%s\n","时间片轮转算法执行结果(时间片",pertime,")：");
print2(rrhead);
}

void FPF(){
structjob *fhead,*fend,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).priority<(*p1).priority)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
fhead=p;
fend=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).priority<(*p1).priority)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*fend).next=p;
fend=p;
}
(*fend).next=NULL;
printf("%s\n","最高优先权优先算法执行结果(非抢占方式)：");
printf("%s\n","进程执行顺序 周转时间");
print1(fhead);
}

void (structjob *p,struct job *p1){
strcpy((*p).name,(*p1).name);
(*p).cometime=(*p1).cometime;
(*p).runtime=(*p1).runtime;
(*p).priority=(*p1).priority;
(*p).finishtime=(*p1).finishtime;
(*p).state=(*p1).state;
}

void print1(structjob *p){
while(p!=NULL){
printf("%-14s%d\n",(*p).name,(*p).finishtime-(*p).cometime);
p=(*p).next;
}
}

void print2(structjob *p){
struct job *head;
head=p;
printf("%s\n","进程执行顺序");
while(head!=NULL){
printf("%3s",(*head).name);
head=(*head).next;
}
printf("\n%s\n","进程周转时间");
head=p;
while(head!=NULL){
if(((*head).finishtime-(*head).cometime)>0)
printf("%-4s%d\n",(*head).name,(*head).finishtime-(*head).cometime);
head=(*head).next;
}
}

网上找的，自己看着办

⑸ 操作系统中的 名词解释：时间片轮转法

好不容易才找到答案：
时间片轮转法主要是分时系统中使用的一种调度算法。时间片轮转法的基本思想是，将CPU 的处理
时间划分成一个个时间片，就绪队列中的诸进程轮流运行一个时间片。当时间片结束时，就强迫运行进程让出CPU，该进程进入就绪队列，等待下一次调度。同时，进程调度又去选择就绪队列中的一个进程，分配给它一个时间片，以投入运行。在轮转法中，时间片长度的选择非常重要，将直接影响系统开销和响应时间。如果时间片长度很小，则调度程序剥夺处理机的次数频繁，加重系统开销；反之，如果时间片长度选择过长，比方说一个时间片就能保证就绪队列中所有进程都执行完毕，则轮转法就退化成先进先出算法
影响时间片大小设置的主要因素有：系统响应时间、就绪进程数目（终端数目）
和计算机处理能力。

⑹ 时间片的轮转调度

时间片轮转调度是一种最古老，最简单，最公平且使用最广的算法。每个进程被分配一个时间段，称作它的时间片，即该进程允许运行的时间。如果在时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。调度程序所要做的就是维护一张就绪进程列表，当进程用完它的时间片后，它被移到队列的末尾。
时间片轮转调度中唯一有趣的一点是时间片的长度。从一个进程切换到另一个进程是需要一定时间的--保存和装入寄存器值及内存映像，更新各种表格和队列等。假如进程切换(process switch) - 有时称为上下文切换(context switch)，需要5毫秒，再假设时间片设为20毫秒，则在做完20毫秒有用的工作之后，CPU将花费5毫秒来进行进程切换。CPU时间的20%被浪费在了管理开销上。
为了提高CPU效率，我们可以将时间片设为500毫秒。这时浪费的时间只有1%。但考虑在一个分时系统中，如果有十个交互用户几乎同时按下回车键，将发生什么情况？假设所有其他进程都用足它们的时间片的话，最后一个不幸的进程不得不等待0.5秒钟才获得运行机会。多数用户无法忍受一条简短命令要0.5秒钟才能做出响应。同样的问题在一台支持多道程序的个人计算机上也会发生。
通常状况下，一个系统中所有的进程被分配到的时间片长短并不是相等的，尽管初始时间片基本相等（在Linux系统中，初始时间片也不相等，而是各自父进程的一半），系统通过测量进程处于“睡眠”和“正在运行”状态的时间长短来计算每个进程的交互性，交互性和每个进程预设的静态优先级（Nice值）的叠加即是动态优先级，动态优先级按比例缩放就是要分配给那个进程时间片的长短。一般地，为了获得较快的响应速度，交互性强的进程（即趋向于IO消耗型）被分配到的时间片要长于交互性弱的（趋向于处理器消耗型）进程。
结论可以归结如下：时间片设得太短会导致过多的进程切换，降低了CPU效率；而设得太长又可能引起对短的交互请求的响应变差。将时间片设为100毫秒通常是一个比较合理的折衷。

⑺ 操作系统的时间片轮转法具体的算法

四、算法实现
1）系统初始化时给每一个进程赋以一个needtime，并将所有进程按needtime从小到大的次序排成一个队列。
2） 取队头进程,并投入运行。
3） 采用相对固定时间片（Time_piece），进程每执行一次，进程占用的CPU时间加Time_piece。
4） 若进程没有运行完，进程needtime减Time，并排到就绪队列的尾部。
5） 如果尚有进程在队列中,那么转入2）
PCB结构：N 进程个数
name 进程名
Time_piece 进程优先数/进程轮转时间片
Cpu_time 进程占用的CPU时间
Need_time 进程到完成还要的时间
Count 计数器
State 进程状态(P,W,F)
Arrive_time到达时间
next 链指针
run 当前运行进程指针
start 就绪队列头指针
end 就绪队列尾指针
finish 完成队列头指针
void insert(PCB *p) //时间片插入函数
void create() //时间片算法创建进程函数
void roundrobin() //时间片算法函数
void firstin() //运行就绪队列的第一个进程

你可以到这个地址下载文章看一下。
'http://wenku..com/view/f3bca1d333d4b14e85246830.html'