操作系统模拟实验单处理机系统的进程调度实验报告

合集下载

实验一、进程调度实验报告

实验一、进程调度实验报告

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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时间,适用于执行时间较长的任务。

实验总结:通过本次实验,我们进一步加深了对操作系统进程调度的理解和认识。

通过编写模拟程序,我们能够清楚地了解不同调度算法的工作原理和对应的性能表现。

在实际应用中,根据任务的特点和需求选择合适的调度算法,能够提高系统的性能和效率。

进程的调度实验报告(3篇)

进程的调度实验报告(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、操作系统: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知道该进程页目录的位置。

模拟调度实验报告(3篇)

模拟调度实验报告(3篇)

第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算法根据进程的优先级进行调度,优先级高的进程优先执行。

具体实现如下:- 设置一个优先级阈值,当进程的优先级高于阈值时,将其加入就绪队列。

- 遍历就绪队列,选择优先级最高的进程执行,直到进程完成或被阻塞。

操作系统进程调度实验报告

操作系统进程调度实验报告

操作系统进程调度实验报告操作系统进程调度实验报告引言:操作系统是计算机系统中的核心软件之一,负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。

进程调度作为操作系统的重要功能之一,负责决定哪个进程可以获得处理器的使用权,以及进程如何在处理器上运行。

本实验旨在通过设计和实现一个简单的进程调度算法,加深对操作系统进程调度原理的理解。

一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程,掌握进程调度算法的实现方法,深入理解不同调度算法的特点和适用场景。

二、实验环境本实验使用C语言进行编程实现,可在Linux或Windows系统下进行。

三、实验内容1. 进程调度算法的选择在本实验中,我们选择了最简单的先来先服务(FCFS)调度算法作为实现对象。

FCFS算法按照进程到达的先后顺序进行调度,即先到先服务。

这种调度算法的优点是简单易实现,但缺点是无法适应不同进程的执行时间差异,可能导致长作业效应。

2. 进程调度的数据结构在实现进程调度算法时,我们需要定义进程的数据结构。

一个进程通常包含进程ID、到达时间、执行时间等信息。

我们可以使用结构体来表示一个进程,例如:```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中,我们需要按照进程到达的先后顺序进行调度。

具体实现时,可以使用一个队列来保存待调度的进程,并按照到达时间的先后顺序将进程入队。

然后,按照队列中的顺序依次执行进程,直到所有进程执行完毕。

4. 实验结果分析通过实现FCFS调度算法,我们可以观察到进程调度的过程和结果。

可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。

通过比较不同调度算法的指标,可以得出不同算法的优缺点。

四、实验步骤1. 定义进程的数据结构,包括进程ID、到达时间和执行时间等信息。

进程调度实验报告答案(3篇)

进程调度实验报告答案(3篇)

第1篇一、实验目的通过本次实验,加深对操作系统进程调度过程的理解,掌握三种基本调度算法(先来先服务(FCFS)、时间片轮转、动态优先级调度)的原理和实现方法,并能够通过编程模拟进程调度过程,分析不同调度算法的性能特点。

二、实验环境1. 操作系统:Linux/Windows2. 编程语言:C/C++3. 开发环境:Visual Studio、Code::Blocks等三、实验内容1. 实现三种基本调度算法:FCFS、时间片轮转、动态优先级调度。

2. 编写代码模拟进程调度过程,包括进程创建、进程调度、进程运行、进程结束等环节。

3. 每次调度后,打印当前运行的进程、就绪队列以及所有进程的PCB信息。

4. 编写实验报告,描述数据结构、算法流程,展示实验结果,并总结心得。

四、实验步骤1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、已用时间、优先数、进程状态等信息。

2. 实现进程调度函数,根据所选调度算法进行进程调度。

3. 编写主函数,初始化进程信息,选择调度算法,并模拟进程调度过程。

4. 每次调度后,打印当前运行的进程、就绪队列以及所有进程的PCB信息。

5. 编写实验报告,描述数据结构、算法流程,展示实验结果,并总结心得。

五、实验结果与分析1. FCFS调度算法实验结果:按照进程到达时间依次调度,每个进程结束后,调度下一个进程。

分析:FCFS调度算法简单,易于实现,但可能会导致进程的响应时间较长,特别是当有大量进程到达时,后到达的进程可能会长时间等待。

2. 时间片轮转调度算法实验结果:每个进程完成一个时间片后,放弃处理机,转到就绪队列队尾。

分析:时间片轮转调度算法能够保证每个进程都能得到一定的运行时间,但可能会出现进程饥饿现象,即某些进程长时间得不到运行。

3. 动态优先级调度算法实验结果:每个进程完成一个时间片后,优先级减1,插入到就绪队列相关位置。

分析:动态优先级调度算法能够根据进程的运行情况动态调整优先级,使得优先级高的进程能够得到更多的运行时间,从而提高系统的响应速度。

进程调度模拟程序实验实验报告

进程调度模拟程序实验实验报告

进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一,它负责合理地分配 CPU 资源给各个进程,以提高系统的性能和效率。

本次实验的目的是通过编写和模拟进程调度程序,深入理解不同的进程调度算法的原理和特点,并比较它们在不同情况下的性能表现。

二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。

操作系统为 Windows 10。

三、实验原理1、先来先服务(FCFS)调度算法先来先服务调度算法按照进程到达的先后顺序进行调度,先到达的进程先获得 CPU 资源。

2、短作业优先(SJF)调度算法短作业优先调度算法优先调度执行时间短的进程。

3、时间片轮转(RR)调度算法时间片轮转调度算法将 CPU 时间划分为固定大小的时间片,每个进程轮流获得一个时间片的 CPU 资源。

四、实验设计1、进程类的设计创建一个进程类,包含进程 ID、到达时间、服务时间、剩余服务时间等属性,以及用于更新剩余服务时间和判断进程是否完成的方法。

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

3、模拟流程(1)初始化进程列表。

(2)按照选定的调度算法进行进程调度。

(3)计算每个进程的等待时间、周转时间等性能指标。

五、实验步骤1、定义进程类```pythonclass Process:def __init__(self, pid, arrival_time, service_time):selfpid = pidselfarrival_time = arrival_timeselfservice_time = service_timeselfremaining_service_time = service_time```2、先来先服务调度算法实现```pythondef fcfs_scheduling(process_list):current_time = 0total_waiting_time = 0total_turnaround_time = 0for process in process_list:if current_time < processarrival_time:current_time = processarrival_timewaiting_time = current_time processarrival_timetotal_waiting_time += waiting_timecurrent_time += processservice_timeturnaround_time = current_time processarrival_timetotal_turnaround_time += turnaround_timeaverage_waiting_time = total_waiting_time / len(process_list)average_turnaround_time = total_turnaround_time / len(process_list) print("先来先服务调度算法的平均等待时间:",average_waiting_time)print("先来先服务调度算法的平均周转时间:",average_turnaround_time)```3、短作业优先调度算法实现```pythondef sjf_scheduling(process_list):current_time = 0total_waiting_time = 0total_turnaround_time = 0sorted_process_list = sorted(process_list, key=lambda x: xservice_time) for process in sorted_process_list:if current_time < processarrival_time:current_time = processarrival_timewaiting_time = current_time processarrival_timetotal_waiting_time += waiting_timecurrent_time += processservice_timeturnaround_time = current_time processarrival_timetotal_turnaround_time += turnaround_timeaverage_waiting_time = total_waiting_time / len(process_list)average_turnaround_time = total_turnaround_time / len(process_list) print("短作业优先调度算法的平均等待时间:",average_waiting_time)print("短作业优先调度算法的平均周转时间:",average_turnaround_time)```4、时间片轮转调度算法实现```pythondef rr_scheduling(process_list, time_slice):current_time = 0total_waiting_time = 0total_turnaround_time = 0ready_queue =while len(process_list) > 0 or len(ready_queue) > 0:for process in process_list:if processarrival_time <= current_time:ready_queueappend(process)process_listremove(process)if len(ready_queue) == 0:current_time += 1continueprocess = ready_queuepop(0)if processremaining_service_time <= time_slice: waiting_time = current_time processarrival_time total_waiting_time += waiting_timecurrent_time += processremaining_service_time turnaround_time = current_time processarrival_time total_turnaround_time += turnaround_time processremaining_service_time = 0else:waiting_time = current_time processarrival_time total_waiting_time += waiting_timecurrent_time += time_sliceprocessremaining_service_time = time_sliceready_queueappend(process)average_waiting_time = total_waiting_time / len(process_list)average_turnaround_time = total_turnaround_time / len(process_list) print("时间片轮转调度算法(时间片大小为", time_slice, ")的平均等待时间:", average_waiting_time)print("时间片轮转调度算法(时间片大小为", time_slice, ")的平均周转时间:", average_turnaround_time)```5、主函数```pythonif __name__ =="__main__":process_list =Process(1, 0, 5),Process(2, 1, 3),Process(3, 2, 8),Process(4, 3, 6)print("先来先服务调度算法:")fcfs_scheduling(process_list)print("短作业优先调度算法:")sjf_scheduling(process_list)time_slice = 2print("时间片轮转调度算法(时间片大小为",time_slice, "):")rr_scheduling(process_list, time_slice)```六、实验结果与分析1、先来先服务调度算法平均等待时间为 575,平均周转时间为 1275。

操作系统模拟实验:单处理机系统的进程调度实验报告

操作系统模拟实验:单处理机系统的进程调度实验报告

数学与计算机学院单处理机系统的进程调度实验报告年级07 学号23 姓名王阳成绩专业信计实验地点主楼402 指导教师王硕实验项目单处理机系统的进程调度实验日期实验报告要求:一、实验目的1、加深对进程概念的理解,明确进程和程序的区别。

2、深入了解系统如何组织进程、创建进程。

3、进一步认识如何实现处理机调度。

二、实验原理三、实验要求1、采用时间片轮转调度算法实现进程调度。

2、确定进程控制块的内容,进程控制块的组织方式。

3、完成进程创建原语和进程调度原语。

4、编写主函数对所做工作进行测试。

四、实验结果(程序)及分析#include <>#define N 10 ext=temp+1;}pcbArea[temp].next=-1;pfree=0;ext;if==-1)=-1;pcbArea[temp].next=-1;return temp;}ext;pcbArea[temp].next=-1;return temp;}ext=-1;}x=;pcbArea[x].bx=;pcbArea[x].cx=;pcbArea[x].dx=;pcbArea[x].name=;pcbArea[x].next=-1;pcbArea[x].pc=;pcbArea[x].psw=;pcbArea[x].status=;}tatus=Running;TIME=SLOT; x;BX=pcbArea[temp].bx;CX=pcbArea[temp].cx;DX=pcbArea[temp].dx;PC=pcbArea[temp].pc;PSW=pcbArea[temp].psw;run=temp; ame);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("请输入进程号,以负数为结束(进程号应保持唯一)。

操作系统实验报告-单处理机系统的进程调度

操作系统实验报告-单处理机系统的进程调度

实验二单处理机系统的进程调度一.实验目的(1)加深对进程概念的理解,明确进程与程序的区别。

(2)深入了解系统如何组织进程、创建进程。

(3)进一步认识如何实现处理机调度。

二.实验内容编写程序完成单处理机系统中的进程调度,要求采用时间片轮转调度算法。

三.实验原理在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.四.实验部分源程序#include<stdio.h>#include<time.h>#include<stdlib.h>/*********************以下是全局数据结构和变量***********************//*PCB 结构*/struct PCB{int pname;int pri;int runtime;int waittime;struct PCB *next;}pcb[7];struct PCB *running; /* 运行指针*/struct PCB *Hready; /*高优先级就绪队列头指针*/struct PCB *Lready; /*低优先级队列头指针*/struct PCB*wait; /*等待队列头指针*/int A=0;/**************************以下是函数说明****************************/ void delay(); /*利用循环实现延迟*/void proc(struct PCB *running); /*模拟进程3-9*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node); /*将node插入到head所指示的队列的尾部*/int proc_switch(); /*进程调度函数*/void proc_wait(); /*进程等待函数*/int proc_wakeup(); /*进程唤醒函数*//************************以下是函数定义及注释************************/ main() /*主函数*/{ int i;/*初始化,创建进程3-9,置低优先级,等待时间为0,依次插入低优先级队列*/for(i=0;i<3;i++){pcb[i].pname=i+3;pcb[i].pri=0;pcb[i].waittime=0;InsertIntoQueueTail(&Lready,&pcb[i]);}wait=NULL;Hready=NULL; /*等待队列和高优先级队列为空*/printf("\n模拟进程调度开始:\n"); /*模拟进程调度开始*/for(;;){ switch(A){case 0:/*无进程等待调度,打印信息并返回*/if(!proc_switch()){printf("/n没有进程在运行返回:\n");getchar(); }break;case 1:proc_wait();break;case 3:case 4:case 5:case 6:proc(running); break;default:printf("\nerror!");exit(-1); }}}/*功能:延迟一个时间片*//*入口参数:无*//*出口参数:无*/void delay(){ int i,j;for(i=0;i<20000;i++)for(j=0;j<10000;j++){}}/*功能:进程3-9*//*入口参数:运行指针*//*出口参数:无*/void proc(struct PCB * running){ int i;srand( (unsigned)time( NULL ) );/*显示当前运行的进程的id*/printf("\n现在进程%d 正在运行\n",running->pname);/*当前进程执行running->runtime个时间片*/for(i=running->runtime;i>0;i--){/*显示剩余的时间片*/printf("剩余的时间片为%d\n",i);/*延迟*/delay();proc_wakeup();/*产生一个1到1000的随机数,若该随机数小余300,当前进程等待,*/ if((rand()%1000+1)<300){printf("进程%d开始等待.\n",running->pname);A=1;return; }}/*显示时间片耗尽,进程转为低优先级就绪状态*/printf("进程%d时间片耗尽\n",running->pname);InsertIntoQueueTail(&Lready,running);A=0;return; }/*功能:将一个节点插入队列尾部*//*入口参数:队列头指针地址head,待插入结点node*//*出口参数:无*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node){ struct PCB *p;node->next=NULL;/*被插入队列为空*/if(*head==NULL){*head=node;return; }/*被插入队列不为空*/else{p=*head;/*找到队列的最后一个结点*/while(p->next!=NULL)p=p->next; p->next=node; }}/*功能:进程调度*//*入口参数:无*//*出口参数:若调度成功,返回1,否则返回0*/int proc_switch() {/*若高优先级就绪队列和低优先级就绪队列均为空,则循环执行进程唤醒*/while(Hready == NULL && Lready == NULL)if(!proc_wakeup()) return 0;/*若高优先级就绪队列非空,则执行其第一个进程,分配2个时间片*/if(Hready!=NULL){running=Hready;Hready=Hready->next;running->runtime=2; }/*若高优先级就绪队列为空,则执行低优先级就绪队列的第一个进程,分配5个时间片*/else{running=Lready;Lready=Lready->next;running->runtime=5; }/*把调度进程的id赋给A*/A=running->pname;return 1; }/*功能:进程等待。

调度算法实验报告总结(3篇)

调度算法实验报告总结(3篇)

第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程,加深对进程调度算法的理解。

实验中,我们重点研究了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种常见的调度算法。

通过编写C语言程序模拟这些算法的运行,我们能够直观地观察到不同调度策略对进程调度效果的影响。

二、实验内容1. 数据结构设计在实验中,我们定义了进程控制块(PCB)作为进程的抽象表示。

PCB包含以下信息:- 进程编号- 到达时间- 运行时间- 优先级- 状态(就绪、运行、阻塞、完成)为了方便调度,我们使用链表来存储就绪队列,以便于按照不同的调度策略进行操作。

2. 算法实现与模拟(1)先来先服务(FCFS)调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。

在模拟过程中,我们首先将所有进程按照到达时间排序,然后依次将它们从就绪队列中取出并分配CPU资源。

(2)时间片轮转(RR)调度算法RR算法将CPU时间划分为固定的时间片,并按照进程到达就绪队列的顺序轮流分配CPU资源。

当一个进程的时间片用完时,它将被放入就绪队列的末尾,等待下一次调度。

(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度。

在模拟过程中,我们为每个进程分配一个优先级,并按照优先级从高到低的顺序进行调度。

3. 输出调度结果在模拟结束后,我们输出每个进程的调度结果,包括:- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时,我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。

三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现,但可能会导致进程的响应时间较长,尤其是在存在大量短作业的情况下。

此外,FCFS算法可能导致某些进程长时间得不到调度,造成饥饿现象。

2. 时间片轮转(RR)调度算法RR算法能够有效地降低进程的响应时间,并提高系统的吞吐量。

然而,RR算法在进程数量较多时,可能会导致调度开销较大。

操作系统实验报告

操作系统实验报告

通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

设计程序摹拟进程的轮转法调度过程。

假设初始状态为:有n 个进程处于就绪状态,有m 个进程处于阻塞状态。

采用轮转法进程调度算法进行调度(调度过程中,假设处于执行状态的进程不会阻塞),且每过t 个时间片系统释放资源,唤醒处于阻塞队列队首的进程。

程序要求如下:1) .输出系统中进程的调度次序;2) .计算CPU 利用率。

硬件环境:Ghost XP SP3 纯净版Y6.0 Pentium(R) Dual-Core CPU E6700 @3.20GHz 3.19 GHz, 1.96 GB 的内存物理地址扩展软件环境:Microsoft Windows XP , Visual Studio 2022#include <iostream>#include <algorithm>#include <queue>using namespace std;const int MaxNum = 100;struct Node{int index;int arriveTime;int rest;};bool NodeCmp(const Node& a,const Node& b){return a.arriveTime < b.arriveTime;}int n; //进程数int ArrivalTime[MaxNum];int ServiceTime[MaxNum];int PServiceTime[MaxNum];int FinishTime[MaxNum];int WholeTime[MaxNum];double WeightWholeTime[MaxNum];bool Finished[MaxNum];double AverageWT,AverageWWT;bool isEnterQue[MaxNum];int cntTimes[MaxNum];void init(){memset(PServiceTime,0,sizeof(PServiceTime));memset(Finished,0,sizeof(Finished));memset(FinishTime,0,sizeof(FinishTime));memset(WholeTime,0,sizeof(WholeTime));memset(WeightWholeTime,0,sizeof(WeightWholeTime)); }int sum(int array[],int n){int sum=0;int i;for(i=0;i<n;i++){sum += array[i];}return sum;}double sum(double array[],int n){double sum=0;int i;for(i=0;i<n;i++){sum += array[i];}return sum;}void print(){int i=0;cout<<"进程完成时间:";for(i=0;i<n;i++){cout<<FinishTime[i]<<' ' ;}cout<<endl;cout<<"周转时间:";for(i=0;i<n;i++){cout<<WholeTime[i]<<' ';}cout<<endl;cout<<"带权周转时间:";for(i=0;i<n;i++){printf("%.2f ",WeightWholeTime[i]);}cout<<endl;}void SearchToEnterQue(queue<Node>& que,Node* pArr,int maxArrivalTime) {int i;for(i=0;i<n;i++){if(pArr[i].arriveTime>maxArrivalTime)break ;if(isEnterQue[pArr[i].index]==false){que.push(pArr[i]);isEnterQue[pArr[i].index] = true;}}}void Work(int q){init();memset(isEnterQue,0,sizeof(isEnterQue));memset(cntTimes,0,sizeof(cntTimes));Node* pNodeArr = new Node[n];int i;for(i=0;i<n;i++){pNodeArr[i].index = i;pNodeArr[i].arriveTime = ArrivalTime[i];pNodeArr[i].rest = ServiceTime[i];}sort(pNodeArr,pNodeArr+n,NodeCmp);int totalTime = sum(ServiceTime,n);int time=pNodeArr[0].arriveTime;queue<Node> que;que.push(pNodeArr[0]);isEnterQue[pNodeArr[0].index]=true;Node cur;cout<<"================================================="<<endl;while(!que.empty()) {cur = que.front();que.pop();cntTimes[cur.index]++;if(cntTimes[cur.index]==1)printf("在%d时刻,进程%d开始执行。

进程调度实验报告

进程调度实验报告

操作系统实验 报告实验项目: 进程调度学 院: 计算机学院专 业:班 级:学 号:姓 名:1. 实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

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

本实验模拟在单处理机情况下的进程调度,加深了解进程调度的工作。

2. 实验内容设计一个按时间片轮转法实现进程调度的程序。

(1)假定系统有五个进程,每一个进程用一个进程控制块PCB 来代表,进程控制块的格式为:其中,进程名——作为进程的标识,假设五个进程的进程名分别为Q 1,Q 2,Q 3,Q 4,Q 5。

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

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

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

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

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

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

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

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

例如,当前轮到Q 2执行,则有:进程名 指针 要求运行时间 已运行时间 状态标志单元(4)进程调度总是选择标志单元指示的进程运行。

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

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

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

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

操作系统进程调度模拟程序实验报告

操作系统进程调度模拟程序实验报告

操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序,以加深对进程调度算法的理解。

二、实验内容1. 实现进程相关的数据结构:进程PCB(Process Control Block)。

2.实现进程的创建、撤销以及调度等操作函数。

3. 实现常见的进程调度算法:先来先服务(FCFS)、最短作业优先(SJF)、轮转调度(RR)、优先级调度(Priority)。

4.编写测试程序,验证实现的进程调度算法在不同场景下的表现。

三、实验过程及结果1.进程PCB的设计与实现进程PCB是进程的核心数据结构,用于存储和管理进程相关的信息,包括进程状态(就绪、运行、阻塞)、优先级、执行时间等。

2.进程的创建、撤销及调度函数的实现(1)进程创建函数:实现进程的创建,包括为其分配空间、初始化进程PCB等。

可以根据实际需求,设定进程的优先级、执行时间等属性。

(2)进程撤销函数:实现进程的撤销,包括释放其占用的资源、回收其使用的空间等。

(3)进程调度函数:根据不同的调度算法,实现进程的调度。

可以通过设置时间片大小、优先级设定等方式,实现不同调度算法的效果。

3.进程调度算法的设计与实现(1)先来先服务(FCFS)调度算法:按照进程到达的先后顺序,依次进行调度。

(2)最短作业优先(SJF)调度算法:根据进程的执行时间,选择执行时间最短的进程进行调度。

(3)轮转调度(RR)算法:按照时间片的大小进行调度,每个进程在一个时间片内执行,超过时间片后,暂停并进入等待队列,让其他进程执行。

(4)优先级调度(Priority)算法:根据进程的优先级,选择优先级最高的进程进行调度。

4.测试程序编写测试程序,模拟不同的进程到达顺序、执行时间和优先级等场景,验证不同调度算法的表现。

四、实验结果与分析通过测试程序的运行结果,观察不同调度算法的特点和效果。

可以得出以下结论:1.FCFS算法适用于进程到达时间差异较大的场景,保证了先到先服务。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数学与计算机学院单处理机系统的进程调度实验报告年级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();
}。

相关文档
最新文档