操作系统实验一处理机调度算法的实现

处理机调度算法实验总结1. 引言处理机调度算法是操作系统中的重要组成部分，它决定了如何合理地分配处理机资源，以提高系统的性能和效率。

本次实验旨在通过实际操作和实验数据的分析，对不同的处理机调度算法进行比较和总结，以便更好地理解和应用这些算法。

2. 实验设计在本次实验中，我们选择了三种常见的处理机调度算法进行比较，分别是先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR）。

我们设计了以下实验方案：2.1 实验环境•操作系统：Windows 10•开发工具：C语言编译器2.2 实验步骤1.设计并实现三个处理机调度算法的代码；2.编写测试用例，包括不同作业的到达时间和服务时间；3.运行代码，记录每个作业的等待时间和周转时间；4.分析和比较三种算法的性能指标；5.总结实验结果。

3. 实验结果经过实验运行和数据记录，我们得到了以下实验结果：3.1 先来先服务（FCFS）•等待时间：1.作业1：02.作业2：103.作业3：15•周转时间：1.作业1：102.作业2：203.作业3：253.2 最短作业优先（SJF）•等待时间：1.作业1：02.作业2：53.作业3：10•周转时间：1.作业1：52.作业2：153.作业3：203.3 时间片轮转（RR）•等待时间：1.作业1：102.作业2：53.作业3：0•周转时间：1.作业1：202.作业2：153.作业3：104. 结果分析根据实验结果，我们可以得出以下结论：4.1 先来先服务（FCFS）•优点：简单易实现；•缺点：平均等待时间较长，不适用于长作业。

4.2 最短作业优先（SJF）•优点：平均等待时间最短；•缺点：无法预测作业的运行时间，可能导致长作业等待时间过长。

4.3 时间片轮转（RR）•优点：对长作业有较好的响应时间；•缺点：平均等待时间较长，不适用于短作业。

5. 实验总结通过本次实验，我们深入了解了三种常见的处理机调度算法，并通过实验数据对其进行了比较和分析。

操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一，本次实验的主要目的是通过模拟不同的处理机调度算法，深入理解操作系统对处理机资源的分配和管理策略，比较不同调度算法的性能差异，并观察它们在不同负载情况下的表现。

二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 Python 38。

实验中使用了 Python 的相关库，如`numpy`、｀matplotlib`等，用于数据生成、计算和图形绘制。

三、实验原理1、先来先服务（FCFS）调度算法先来先服务算法按照作业到达的先后顺序进行调度。

先到达的作业先被服务，直到完成或阻塞，然后再处理下一个到达的作业。

2、短作业优先（SJF）调度算法短作业优先算法选择预计运行时间最短的作业先执行。

这种算法可以有效地减少作业的平均等待时间，但可能导致长作业长时间等待。

3、时间片轮转（RR）调度算法时间片轮转算法将处理机的时间分成固定长度的时间片，每个作业轮流获得一个时间片的处理时间。

当时间片用完后，如果作业还未完成，则将其放入就绪队列的末尾等待下一轮调度。

4、优先级调度算法优先级调度算法为每个作业分配一个优先级，优先级高的作业先被执行。

优先级可以根据作业的性质、紧急程度等因素来确定。

四、实验内容与步骤1、数据生成首先，生成一组模拟的作业，包括作业的到达时间、预计运行时间和优先级等信息。

为了使实验结果更具代表性，生成了不同规模和特征的作业集合。

2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。

在实现过程中，严格按照算法的定义和规则进行处理机的分配和调度。

3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果：平均等待时间：作业在就绪队列中的等待时间的平均值。

平均周转时间：作业从到达系统到完成的时间间隔的平均值。

系统吞吐量：单位时间内完成的作业数量。

4、实验结果分析对每种调度算法进行多次实验，使用不同的作业集合，并记录相应的性能指标数据。

处理机调度实验报告处理机调度实验报告一、引言处理机调度是计算机操作系统中一个重要的概念，它涉及到如何合理地分配处理机资源以提高系统的运行效率。

本文将针对处理机调度进行实验，探讨不同调度算法对系统性能的影响。

二、实验目的本实验的目的是通过模拟不同的处理机调度算法，比较它们在不同负载下的性能表现，进而分析其优缺点，为实际操作系统的调度算法选择提供参考。

三、实验方法1. 实验环境本实验使用了一台配置较高的计算机作为实验环境，操作系统为Linux，处理器为Intel Core i7，内存为8GB。

2. 实验设置为了模拟不同的负载情况，我们使用了三个不同的测试程序：程序A、程序B和程序C。

程序A是一个计算密集型任务，程序B是一个I/O密集型任务，程序C是一个混合型任务。

3. 实验步骤首先，我们分别运行程序A、程序B和程序C，并记录它们的运行时间。

然后，我们使用不同的调度算法来调度这些任务，并记录它们的运行时间和系统资源利用率。

四、实验结果与分析1. 调度算法1：先来先服务（First-Come, First-Served，FCFS）FCFS算法按照任务到达的先后顺序进行调度，即先到先服务。

实验结果显示，在计算密集型任务下，FCFS算法表现较好，但在I/O密集型任务和混合型任务下，其性能明显下降。

这是因为在FCFS算法中，任务的执行顺序是固定的，无法根据任务的特性进行灵活调度。

2. 调度算法2：最短作业优先（Shortest Job First，SJF）SJF算法根据任务的执行时间进行调度，即执行时间最短的任务先执行。

实验结果显示，在计算密集型任务和混合型任务下，SJF算法表现较好，但在I/O密集型任务下，其性能较差。

这是因为在I/O密集型任务中，任务的执行时间不仅与计算量有关，还与I/O操作的耗时有关，因此SJF算法无法有效地进行调度。

3. 调度算法3：时间片轮转（Round Robin，RR）RR算法将处理机的运行时间划分为若干个时间片，每个任务在一个时间片内执行一定的时间，然后切换到下一个任务。

实验二：处理机调度一、实验目的：1、了解Linux下Emacs编辑器的使用方法，掌握各种常用的键盘操作命令；2、理解并掌握处理机调度算法。

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

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

本实验模拟在单处理机情况下处理机调度。

1、优先调度算法实现处理机的调度：设计思路：1每个进程用一个进程控制块PCB来代表，进程控制块包括进程名(进程的标识、指针(按优先数的大小把进程连成队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针为"0"、要求运行时间、优先数、状态(就绪、结束；2每次运行处理机调度程序前，为每个进程确定它的"优先数"和"要求运行时间"；3把给定的进程按优先数的大小连成队列，用一单元指出队首进程；4每模拟执行一次进程，优先数减一，要求运行时间减一；5如果要求运行的时间>=0，再将它加入队列（按优先数的大小插入，重置队首标志）；如果要求运行的时间=0，那么把它的状态修改为结束，且推出队列；6若就绪队列不为空，重复上述，直到所有的进程都结束；7程序有显示和打印语句，每次运行后显示变化。

2、按时间片轮转法实现处理机调度：设计思路：1每个进程用一个进程控制块PCB来代表，进程控制块包括进程名(进程的标识、指针(把进程连成循环队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针指出第一个进程的进程控制块首地址、已运行时间、状态(就绪、结束；2每次运行处理机调度程序前，为每个进程确定它的"要求运行时间"；3用指针把给定的进程按顺序排成循环队列，用另一标志单元记录轮到的进程；4每模拟运行一次进程，已运行时间加一；5进程运行一次后，把该进程控制块的指针值送到标志单元，以指示下一个轮到的进程。

操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。

2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。

3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。

该算法按照进程到达的先后顺序进行调度。

在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。

3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。

在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。

如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。

在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。

- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。

- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。

5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。

通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。

在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

操作系统单处理机系统的进程调度第一篇：操作系统单处理机系统的进程调度一.实验内容描述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知道该进程页目录的位置。

操作系统实验一处理机调度算法的实现操作系统中的处理机调度算法是为了合理地分配和利用处理器资源，提高系统的性能和响应速度。

这些算法主要用于决定下一个要执行的进程或线程。

在本篇文章中，我们将介绍几种常见的处理机调度算法以及它们的实际应用。

首先，我们要了解什么是处理机调度算法。

处理机调度是指从就绪队列中选择一个进程，并分配处理机给它。

调度算法的目标是合理地选择进程，以达到最佳的系统性能指标。

这些指标可以包括响应时间、吞吐量、公平性等。

最简单的调度算法是先来先服务（FCFS）。

这种算法按照进程到达的顺序来进行调度。

当一个进程完成后，下一个进程在队列头被选中执行。

FCFS算法的优点是实现简单，但缺点是不考虑进程的执行时间，导致平均等待时间较长。

FCFS主要用于批处理环境中，例如打印任务的排队。

另一种常见的调度算法是短作业优先（SJF）。

这种算法选择剩余执行时间最短的进程进行调度。

为了实现SJF算法，系统需要预测进程的执行时间，这可能是一个难题。

SJF算法的优点是能够最小化平均等待时间，但缺点是可能导致长作业的饥饿。

SJF算法主要用于交互式系统或具有预测性能的任务。

另一个常见的调度算法是轮转调度（RR）。

这种算法将处理机时间分成一定大小的时间片（时间片就是一段处理器运行的时间），每个进程在一个时间片内执行，然后进入队列尾部等待。

轮转调度算法的目的是实现公平性，每个进程都有机会被执行。

RR算法的优点是能够减少各个进程的响应时间，但缺点是可能造成高负载下的处理机浪费。

RR算法主要用于实时系统或多用户环境。

另一个调度算法是最高响应比优先（HRRN）。

响应比是指进程等待时间与预计执行时间的比率。

HRRN算法选择响应比最高的进程进行调度。

这种算法考虑了等待时间和执行时间的权衡，能够实现较好的性能。

但是，HRRN算法计算响应比需要实时监测和更新进程的等待时间和执行时间。

HRRN算法适用于交互式或多用户系统。

还有一种常见的调度算法是最短剩余时间优先（SRTF）。

天津理工大学
计算机与通信工程学院
实验报告
2011至2012学年第二学期
课程名称操作系统
实验（ 1 ）实验名称处理机调度算法的实现
实验时间 2012 年 5月 5日第 1 节至第 6 节学号姓名******专业
主讲教师
辅导教师
软件环境VC++6
试验结果：1.执行结果
2. 结果分析
当程序启动时，用户可以选择不同的调度算法。

然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。

进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。

判断进程容器中是否有新的进程可以加入就绪队列。

实现处理机调度课程设计一、课程目标知识目标：1. 让学生理解处理机调度的基本概念，掌握其功能和重要性；2. 学会分析不同处理机调度算法的特点和优缺点；3. 掌握几种常见的处理机调度算法，如先来先服务、短作业优先、优先级调度等；4. 了解处理机调度在操作系统中的作用和影响。

技能目标：1. 培养学生运用处理机调度算法解决实际问题的能力；2. 提高学生分析、设计、优化调度算法的技能；3. 学会使用相关工具和软件模拟处理机调度过程。

情感态度价值观目标：1. 培养学生对操作系统学科的兴趣和热情；2. 增强学生的团队合作意识和解决问题的能力；3. 引导学生认识到处理机调度在提高计算机系统性能方面的重要性。

分析课程性质、学生特点和教学要求：1. 课程性质：本课程为计算机科学与技术专业核心课程，具有较强的理论性和实践性；2. 学生特点：学生已具备一定的计算机操作系统知识，具备一定的编程基础；3. 教学要求：结合实际案例，采用任务驱动法，引导学生主动探索和解决问题。

二、教学内容1. 处理机调度基本概念：处理机调度的定义、作用、分类和性能指标；2. 处理机调度算法：- 先来先服务（FCFS）调度算法；- 短作业优先（SJF）调度算法；- 优先级调度算法；- 时间片轮转调度算法；- 多级反馈队列调度算法；3. 处理机调度算法性能分析：分析各种调度算法的优缺点及适用场景；4. 处理机调度算法实现：结合实际案例，编写程序实现各种调度算法；5. 处理机调度在操作系统中的应用：探讨处理机调度在操作系统中的重要性及影响。

教学安排和进度：第1周：处理机调度基本概念；第2周：先来先服务（FCFS）调度算法；第3周：短作业优先（SJF）调度算法；第4周：优先级调度算法；第5周：时间片轮转调度算法；第6周：多级反馈队列调度算法；第7周：处理机调度算法性能分析；第8周：处理机调度算法实现及实践；第9周：处理机调度在操作系统中的应用。

教材章节关联：《计算机操作系统》第3章“处理机管理”，第4章“进程调度与死锁”，结合课本内容进行讲解和拓展。

处理机调度算法的实现标题：处理机调度算法的实现正文：处理机调度算法是操作系统中的关键部分，它决定了处理机如何分配给各个进程以提高系统的性能和效率。

本文将介绍几种常见的处理机调度算法以及它们的实现方式。

1.先来先服务调度算法（FCFS）：先来先服务调度算法是最简单的调度算法之一。

它按照进程到达的顺序来分配处理机。

实现这个算法时，需要维护一个就绪队列，并按照进程到达的时间将进程依次加入队列。

当处理机空闲时，从队列中选择最先到达的进程进行执行。

2.短作业优先调度算法（SJF）：短作业优先调度算法是一种非抢占式调度算法，它根据进程的执行时间来进行调度。

在实现这个算法时，需要预测每个进程的执行时间，并将执行时间最短的进程优先分配处理机。

这需要对每个进程的执行时间进行估计，可以通过历史数据或统计方法来获得。

3.优先级调度算法：优先级调度算法根据进程的优先级来进行调度。

每个进程都有一个与之相关联的优先级，优先级较高的进程会被先执行。

实现这个算法时，需要定义一个合适的优先级评估方式，并在处理机空闲时选择优先级最高的进程进行执行。

4.时间片轮转调度算法：时间片轮转调度算法是一种抢占式调度算法，它将处理机的时间分割成多个时间片，每个进程在一个时间片内执行一段时间，然后让出处理机给下一个进程。

实现这个算法时，需要设置合适的时间片长度，并使用一个计时器来控制每个进程的执行时间。

以上只是几种常见的处理机调度算法，实际应用中还有其他各种调度算法，如多级反馈队列调度算法、最短剩余时间优先调度算法等。

选择合适的调度算法可以提高系统的性能和响应速度。

在实际实现时，还需要考虑多线程、多核处理器、资源分配等因素来优化调度算法的性能。

总结起来，处理机调度算法的实现需要根据实际需求选择合适的算法，并结合系统特性进行调优。

这些算法的实现应该具有清晰的思路，流畅的表达，并遵循文章中提到的几点注意事项，以确保文章的质量和阅读体验。

处理机调度算法的实现调度算法是计算机科学中一个重要的概念，它涉及到对处理机的任务进行合理的分配和调度，以提高计算机系统的性能和效率。

在现代计算机系统中，有各种不同的调度算法可供选择，每种算法都有其独特的特点和适用场景。

调度算法的实现是指将某种具体的调度策略编写成代码并应用于计算机系统中。

通过实现调度算法，我们能够使计算机系统在处理任务时更加高效和稳定。

为了实现一个有效的调度算法，我们需要考虑多个因素，包括任务的优先级、处理机的资源利用率、任务的完成时间等。

本文将介绍调度算法的背景和重要性，以及如何进行调度算法的实现。

通过理解调度算法的原理和实现方法，我们能够更好地应用适合的调度算法来优化计算机系统的性能。

调度算法是计算机中重要的概念，用于管理和安排处理机资源以有效地执行任务。

下面将解释调度算法的基本概念，包括作业调度、进程调度和线程调度。

作业调度作业调度是指在多道程序设计中，根据一定的策略和算法，合理地安排和调度作业的执行顺序和时间。

作业调度的目标是提高系统的利用率和吞吐量，减少等待时间和响应时间。

常见的作业调度算法包括先来先服务（FCFS）、最短作业优先（SJF）和优先级调度等。

进程调度进程调度是指在操作系统中，根据一定的策略和算法，合理地安排和调度进程的执行顺序和时间。

进程调度的目标是实现公平性、高效性和吞吐量的平衡。

常见的进程调度算法包括时间片轮转调度、最短剩余时间优先（SRTF）和多级反馈队列调度等。

线程调度线程调度是指在多线程环境下，根据一定的策略和算法，合理地安排和调度线程的执行顺序和时间。

线程调度的目标是提高系统的并发性、响应性和效率。

常见的线程调度算法包括抢占式调度、优先级调度和轮询调度等。

以上就是调度算法的基本原理和概念。

了解和掌握这些调度算法对于有效地管理和利用处理机资源至关重要。

常见的处理机调度算法先来先服务（FCFS）：先到先服务算法是一种简单的调度算法，按照进程到达的顺序分配处理机资源。

操作系统实验处理机调度C语言实现
一、实验目的
1.理解操作系统分时调度的概念；
2.熟悉程序跟踪法；
3.开发一个C语言程序，实现调度算法。

二、实验内容
1.了解操作系统的分时调度概念，理解调度算法的实现原理；
2.根据操作系统调度实验案例中的要求，编写C语言程序并调试；
3.按照调度实验案例要求，进行操作系统分时调度实验，实现调度算法；
4.使用程序跟踪方法，对实验结果进行分析，并分析程序的调度结果。

三、实验步骤
1.仔细阅读操作系统分时调度实验，了解其原理；
2.编写C语言程序，实现调度算法；
3.编写操作系统分时调度实验的调度规则，并利用前面编写的C语言
程序实现调度规则；
4.设置实验测试数据，对操作系统分时调度进行模拟实验；
5.利用程序跟踪方法，进行实验结果分析及性能测试；
6.根据实验结果，对调度算法进行改进，提高系统调度效率；
7.完成实验报告，并总结分析程序的调度结果。

四、实验结果分析
1.首先，本次实验中，编写的C语言程序完成了操作系统分时调度要求，可以正确的实现调度算法。

2.其次，在实验中。

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

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

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

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

三、实习题目本实习有两个题，学生可选择其中的一题做实习。

第二题：设计一个按时间片轮转法实现处理器调度的程序。

[提示]：(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：Q1，Q2，Q3，Q4，Q5。

指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。

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

已运行时间——假设进程已经运行的单位时间数，初始值为“0”。

状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。

当一个进程运行结束后，它的状态为“结束”，用“E”表示。

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

(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如，当前轮到P2执行，则有：标志单元，K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选择标志单元指示的进程运行。

由于本实习是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。

在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5) 进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。

实验报告学院（系）名称：计算机与通信工程学院姓名学号专业计算机科学与技术班级2009级3班实验项目实验一：处理机调度算法的实现课程名称操作系统课程代码0668036实验时间2011 年11月17日第3、4节2011 年11月21日第7、8节2011 年11月24日第3、4节实验地点软件实验室7-216批改意见成绩教师签字：实验内容：1．设定系统中有五个进程，每一个进程用一个进程控制块表示。

2．输入每个进程的“优先数”和“要求运行时间”。

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

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

4．处理机调度总是选队首进程运行。

采用动态优先数算法，进程每运行一次优先数就减“1”，同时将运行时间减“1”。

5．若某进程运行时间为零，则将其状态置为“结束”,且退出队列。

6．运行所设计程序，显示或打印逐次被选中进程的进程名，以及进程控制块的动态变化过程。

实验要求：1．详细描述实验设计思想、程序结构及各模块设计思路；2．详细描述程序所用数据结构及算法；3．明确给出测试用例和实验结果；4．为增加程序可读性，在程序中进行适当注释说明；5．认真进行实验总结，包括：设计中遇到的问题、解决方法与收获等；6．实验报告撰写要求结构清晰、描述准确逻辑性强；7．实验过程中，同学之间可以进行讨论互相提高，但绝对禁止抄袭。

【实验过程记录（源程序、测试用例、测试结果及心得体会等）】程序运行代码如下：#include<stdio.h>#include <stdlib.h>#include <conio.h>struct PCB{//定义进程控制块PCB，包括进程的名字，优先运行数，运行时间char name[20];int pri;int time;struct PCB * next;}*k;struct LinkQueue{//链式队列节点类型定义PCB * front;PCB * rear;};LinkQueue InitQueue(){//链式队列初始化LinkQueue Q;PCB * p;p=(PCB*)malloc(sizeof(PCB));//申请头结点存储空间if(p){Q.front=Q.rear=p;Q.front->next=NULL;//头结点指针域置空return Q;}else{printf("初始化队列失败，程序运行终止！\n");//初始化失败exit(0);}}LinkQueue sort(LinkQueue Q,PCB * p){//定义将进程按给定的优先数从大到小连成就绪队列的函数PCB *temp1;PCB *temp2;if(Q.rear==Q.front){Q.front->next=p;Q.rear=p;}else{temp1=Q.front;temp2=temp1->next;while(temp2->pri>=p->pri && temp2->next!=NULL){temp1=temp2;temp2=temp1->next;}if(temp2->next==NULL && temp2->pri>=p->pri){temp2->next=p;Q.rear=p;}else{p->next=temp1->next;temp1->next=p;}}return Q;}LinkQueue input(LinkQueue Q)//此为进程控制块函数{for(int i=1;i<=5;i++){printf("第%d号进程：\n",i);k=(PCB*)malloc(sizeof(PCB));printf("\n请输入进程的名称：");scanf("%s",k->name);printf("\n请输入进程的优先数：");scanf("%d",&k->pri);printf("\n请输入进程的运行时间：");scanf("%d",&k->time);printf("\n");k->next=NULL;Q=sort(Q,k);//一定注意，要调用上面定义的sort函数}return Q;}void check(LinkQueue Q)//建立进程查看函数{PCB * p;p=(PCB *)malloc(sizeof(PCB));p=Q.front->next;printf("已输入的五个进程为：\n");while(p!=NULL){printf("进程名是：%s，状态为：就绪，优先数为：%d，需要运行的时间为：%d\n",p->name,p->pri,p->time);p=p->next;}}LinkQueue running(LinkQueue Q)//建立进程就绪函数{if(k->time==0) {printf("运行后进程[%s] 已完成，状态为：结束。

操作系统实验报告处理机调度算法的实现*名：***学号： ********班级：09计算机1一、实验名称及要求1、实验名称：处理机调度算法的实现2、实验要求：了解操作系统处理机调度概念的基本概念，处理机调度程序的功能，常用的处理机调度算法。

C或C++编程方法与语句格式，提前初步编好试验程序。

3、实验方式：通过实验室的微机上机，实际调试程序。

4、实验环境：Windows操作系统环境下的个人微机Ｃ或Ｃ＋＋程序设计语言二、实验内容１．设定系统中有五个进程，每一个进程用一个进程控制块表示。

２．输入每个进程的“优先数”和“要求运行时间”。

３．为了调度方便，将五个进程按给定的优先数从大到小连成就绪队列。

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

４．处理机调度总是选队首进程运行。

采用动态优先数算法，进程每运行一次优先数就减“１”，同时将运行时间减“１”。

５．若要求运行时间为零，则将其状态置为“结束”，且对出队列。

６．运行所设计进程，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

三、实验程序#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb /* 定义进程控制块PCB */{char name[20];char state;int super;int ntime;int rtime;struct pcb* link;} *ready=NULL,*p;typedef struct pcb PCB;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;}}void input() /* 建立进程控制块函数*/{int i,num;printf("\n 请输入进程数: ");scanf("%d",&num);for(i=1;i<=num;i++){printf("\n 进程号:No.%d\n",i);p=getpch(PCB);printf("\n 请输入进程名:");scanf("%s",p->name);printf("\n 请输入进程的优先数:");scanf("%d",&p->super);printf("\n 请输入进程的运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='W';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0;PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n 进程名\t 进程状态\t 优先数\t 需要运行时间\t 已经运行时间\n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}void check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** 当前正在运行的进程是:\n"); /*显示当前运行进程*/disp(p);pr=ready;printf("\n **** 当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ {printf("\n 进程 [%s] 已完成.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)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 现在是第%d次运行： \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按回车键继续......\n");}printf("\n\n 进程已经完成.\n");}四、实验结果五．实验总结进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。