下载文档原格式
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 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分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。
3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。
4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。
（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。
（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。
（4）将实验过程和结果进行记录整理，撰写实验报告。
3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一，本次实验的主要目的是通过模拟不同的处理机调度算法，深入理解操作系统对处理机资源的分配和管理策略，比较不同调度算法的性能差异，并观察它们在不同负载情况下的表现。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 Python 38。
实验中使用了 Python 的相关库，如`numpy`、｀matplotlib`等，用于数据生成、计算和图形绘制。
三、实验原理1、先来先服务（FCFS）调度算法先来先服务算法按照作业到达的先后顺序进行调度。
先到达的作业先被服务，直到完成或阻塞，然后再处理下一个到达的作业。
2、短作业优先（SJF）调度算法短作业优先算法选择预计运行时间最短的作业先执行。
这种算法可以有效地减少作业的平均等待时间，但可能导致长作业长时间等待。
3、时间片轮转（RR）调度算法时间片轮转算法将处理机的时间分成固定长度的时间片，每个作业轮流获得一个时间片的处理时间。
当时间片用完后，如果作业还未完成，则将其放入就绪队列的末尾等待下一轮调度。
4、优先级调度算法优先级调度算法为每个作业分配一个优先级，优先级高的作业先被执行。
优先级可以根据作业的性质、紧急程度等因素来确定。
四、实验内容与步骤1、数据生成首先，生成一组模拟的作业，包括作业的到达时间、预计运行时间和优先级等信息。
为了使实验结果更具代表性，生成了不同规模和特征的作业集合。
2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。
在实现过程中，严格按照算法的定义和规则进行处理机的分配和调度。
3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果：平均等待时间：作业在就绪队列中的等待时间的平均值。
平均周转时间：作业从到达系统到完成的时间间隔的平均值。
系统吞吐量：单位时间内完成的作业数量。
4、实验结果分析对每种调度算法进行多次实验，使用不同的作业集合，并记录相应的性能指标数据。
操作系统实验单处理器系统的进程调度一、实验目的1、加深进程概念理解，明确进程与程序区别。
2、理解操作系统中进程的组织、创建和调度等方法。
二、实验内容编写程序完成单处理器系统的进程调度，要求采用时间片轮转法调度策略。
具体内容：1、确定PCB内容及其组织方式；2、要求模拟进程空闲（新）、就绪、运行、阻塞和完成5个状态；3、实现进程创建、进程调度、进程阻塞和进程唤醒4个功能（原语）；4、编写主函数对整个系统进程测试。
三、提示关键三点：（1）如何组织进程：●确定PCB内容：标识信息、状态和运行时间与存储地址等信息、现场信息、管理信息●PCB组织方式：相同状态的进程PCB构成一个队列（即有空闲、就绪、运行、阻塞和完成5个队列）（2）如何创建进程：●申请PCB（从空闲队列）—> 申请资源—> 填写PCB—>挂就绪队列（3）如何实现处理机调度及进程状态切换：●采用先来先服务（FCFS）调度策略实现进程调度；●从就绪队列选择一个进程；摘取PCB，挂运行队列；修改状态等PCB内容；保存现场、恢复现场；●模拟运行--可以按照两种场景模拟进程运行：（1）可以预先设置好各进程的运行时间、I/O时间、I/O发生的时刻等信息（可以放在一个文件中，创建进程时置入PCB），之后操作系统控制进程运行，实现状态切换，直到全部进程完成。
（2）亦可以采用人工干预方式控制进程状态切换（运行时间已预先设置），比如输入“Esc”进入“阻塞”状态，输入“Enter”则选择（新）进程运行（进程调度），当前进程回到就绪状态;输入“wakeup”,再选择阻塞进程，则被选中的阻塞进程回到就绪状态；输入“finished”，当前进程运行结束，回到完成状态；●修改（剩余）运行时间。
四、测试输出●从文件输入创建进程所需信息，创建进程的数目可控（手工输入）；●进行进程调度。
被调度上的进程（正在运行）输出：（1）退出CPU的进程名及其PCB内容。
一、实验目的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算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
操作系统进程调度模拟程序实验报告实验目的：了解操作系统进程调度的基本原理和方法，通过编写模拟程序来验证调度算法的正确性。
实验内容：1. 实现进程调度模拟程序，包括进程的创建、调度、挂起、恢复和销毁等基本操作。
2. 实现三种常用的调度算法：先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR）。
3. 对比不同调度算法的性能，包括平均等待时间、平均周转时间和平均响应时间等指标。
实验步骤：1. 首先定义进程类Process，包括进程的ID、到达时间、执行时间和优先级等属性。
2. 实现创建进程的函数create_process，通过用户输入的方式创建多个进程，并保存到一个进程队列中。
3. 根据选择的调度算法，实现调度函数schedule，按照对应的算法对进程进行调度，并记录每个进程的执行时间和等待时间等信息。
4. 对于FCFS算法，按照进程的到达时间进行排序，然后按顺序执行。
5. 对于SJF算法，按照进程的执行时间进行排序，然后按顺序执行。
6. 对于RR算法，设定一个时间片大小，每个进程执行一个时间片后，将其放回队列末尾，然后继续执行下一个进程，直到所有进程都执行完毕。
7. 在各个调度算法中计算平均等待时间、平均周转时间和平均响应时间等指标，并输出结果。
实验结果：通过对不同进程和不同调度算法的模拟，可以得到如下结果：1. FCFS调度算法的平均等待时间较长，不适用于执行时间较长的任务。
2. SJF调度算法的平均等待时间和平均周转时间较短，适用于执行时间较短的任务。
3. RR调度算法能够平均分配CPU时间，适用于执行时间较长的任务。
实验总结：通过本次实验，我们进一步加深了对操作系统进程调度的理解和认识。
通过编写模拟程序，我们能够清楚地了解不同调度算法的工作原理和对应的性能表现。
在实际应用中，根据任务的特点和需求选择合适的调度算法，能够提高系统的性能和效率。
第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、操作系统：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知道该进程页目录的位置。
第1篇一、实验背景进程调度是操作系统核心功能之一，它负责在多道程序环境下，按照一定的策略对进程进行调度，以确保系统资源的合理分配和高效利用。
为了加深对进程调度算法的理解，本次实验采用模拟的方式，实现了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种算法，并对实验过程进行了详细记录和分析。
二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。
2. 掌握进程控制块（PCB）的设计与实现。
3. 通过模拟实验，验证三种调度算法的执行效果。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验内容1. 定义进程控制块（PCB）进程控制块是操作系统用于描述和管理进程的实体，它包含了进程的基本信息。
本实验中，PCB包含以下字段：- 进程ID：唯一标识一个进程。
- 到达时间：进程进入就绪队列的时间。
- 需要运行时间：进程完成所需的时间。
- 已运行时间：进程已运行的时间。
- 状态：进程当前的状态（就绪、运行、阻塞、完成）。
2. 实现三种调度算法（1）先来先服务（FCFS）算法FCFS算法按照进程到达就绪队列的顺序进行调度，先到先服务。
具体实现如下：- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，依次执行进程，直到进程完成或被阻塞。
（2）时间片轮转（RR）算法RR算法将CPU时间划分为时间片，每个进程运行一个时间片后，让出CPU，等待下一个时间片。
具体实现如下：- 设置一个时间片大小。
- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，每个进程执行一个时间片，如果进程未完成，则将其加入就绪队列队尾。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度，优先级高的进程优先执行。
具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。
- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。
数学与计算机学院单处理机系统的进程调度实验报告年级07 学号2007429023 姓名王阳成绩
专业信计实验地点主楼402 指导教师王硕
实验项目单处理机系统的进程调度实验日期
实验报告要求:
一、实验目的
1、加深对进程概念的理解,明确进程与程序的区别。
2、深入了解系统如何组织进程、创建进程。
3、进一步认识如何实现处理机调度。
二、实验原理
三、实验要求
1、采用时间片轮转调度算法实现进程调度。
2、确定进程控制块的内容,进程控制块的组织方式。
3、完成进程创建原语与进程调度原语。
4、编写主函数对所做工作进行测试。
四、实验结果(程序)及分析
#include <stdio、h>
#define N 10 //系统中所允许的最大进程数量
#define SLOT 5 //时间片大小
//进程状态枚举
typedef enum
{
Running, //运行状态
Aready, //就绪状态
Blocking //阻塞状态
} ProStatus;
//进程控制块
typedef struct
{
int name; //进程标识符
ProStatus status; //进程状态
int ax,bx,cx,dx; //通用寄存器
int pc; //程序计数器寄存器
int psw; //程序状态字寄存器
int next; //指向下一个进程的指针
} PCB;
//就绪队列指针
typedef struct
{
int head; //头指针
int tail; //尾指针
} Ready;
//模拟寄存器
int PSW,AX,BX,CX,DX,PC,TIME;
//PCB的静态链表
PCB pcbArea[N]; //模拟PCB区域的数组
int run; //运行状态程序的指针
Ready ready; //就绪队列指针
int pfree; //空闲队列的指针
//初始化运行状态进程指针
void InitRun()
{
run=-1;
}
//初始化就绪状态队列
void InitReady()
{
ready、head=ready、tail=-1;
}
//初始化空闲队列
void InitFree()
{
int temp;
for(temp=0;temp<N-1;temp++)
{
pcbArea[temp]、next=temp+1;
}
pcbArea[temp]、next=-1;
pfree=0;
}
//就绪队列出队
int PopReady() //返回结点在PCB区域数组的编号{
int temp;
if(ready、head==-1)
{
操作系统模拟实验单处理机系统的进程调度实验报告printf("就绪队列为空,不能出队。
\n");
return -1;
}
temp=ready、head;
ready、head=pcbArea[temp]、next;
if(ready、head==-1)
ready、tail=-1;
pcbArea[temp]、next=-1;
return temp;
}
//空闲队列出队
int PopFree() //返回结点在PCB区域数组的编号
{
int temp;
if(pfree==-1)
{
printf("空闲队列为空,不能出队。
\n");
return -1;
}
temp=pfree;
pfree=pcbArea[temp]、next;
pcbArea[temp]、next=-1;
return temp;
}
//就绪队列入队
void PushReady(int x) //x为入队结点的编号
{
int temp;
if(ready、head==-1)
{
ready、head=x;
ready、tail=x;
}
else
{
temp=ready、tail;
ready、tail=x;
}
pcbArea[ready、tail]、next=-1;
}
//创建PCB
void CreatePCB(int x,PCB pcb) //x为要创建PCB在PCB区域数组的编号{
pcbArea[x]、ax=pcb、ax;
pcbArea[x]、bx=pcb、bx;
pcbArea[x]、cx=pcb、cx;
操作系统模拟实验单处理机系统的进程调度实验报告
pcbArea[x]、dx=pcb、dx;
pcbArea[x]、name=pcb、name;
pcbArea[x]、next=-1;
pcbArea[x]、pc=pcb、pc;
pcbArea[x]、psw=pcb、psw;
pcbArea[x]、status=pcb、status;
}
//创建进程函数
void Create(PCB pcb)
{
int temp;
if(pfree==-1)
{
printf("空闲队列为空,不能创建进程。
\n");
return;
}
temp=PopFree();
pcb、status=Aready;
CreatePCB(temp,pcb);
PushReady(temp);
}
//进程调度函数
void Schedule()
{
int temp;
if(ready、head==-1)
{
printf("系统内没有进程可以调度。
");
return;
}
temp=PopReady();
pcbArea[temp]、status=Running;
TIME=SLOT; //恢复CPU现场
AX=pcbArea[temp]、ax;
BX=pcbArea[temp]、bx;
CX=pcbArea[temp]、cx;
DX=pcbArea[temp]、dx;
PC=pcbArea[temp]、pc;
PSW=pcbArea[temp]、psw;
run=temp; //将选中的进程赋给运行指针
printf("当前运行的程序:\n"); //输出调度结果
printf("进程号:%d\n",pcbArea[run]、name);
printf("进程状态:%d\n",pcbArea[run]、status);
printf("寄存器内容:\nAX\tBX\tCX\tDX\tPC\tPSW\n");
printf("%d\t%d\t%d\t%d\t%d\t%d\n",
pcbArea[run]、ax,pcbArea[run]、bx,pcbArea[run]、cx,pcbArea[run]、dx,pcbArea[run]、
操作系统模拟实验单处理机系统的进程调度实验报告
pc,pcbArea[run]、psw);
}
void main()
{
int temp;
PCB tmp_pcb;
printf("请输入进程号,以负数为结束(进程号应保持唯一)。
\n\n按任意键进入输入模式:");
getchar();
InitRun();
InitReady();
InitFree();
printf("请开始输入进程号:\n");
while(1)
{
scanf("%d",&temp);
if(temp<0)
break;
tmp_pcb、name=temp;
tmp_pcb、ax=temp;
tmp_pcb、bx=temp;
tmp_pcb、cx=temp;
tmp_pcb、dx=temp;
tmp_pcb、pc=temp;
tmp_pcb、psw=temp;
Create(tmp_pcb);
}
printf("\n");
Schedule();
}。
