实验一进程调度实验报告书
进程调度实验【实验报告】
实验一进程调度实验专业:信息管理与信息系统学号:2014******姓名:陈*实验日期:2016年11月11日一、实验目的通过本实验,采用动态优先权优先的调度算法编写和调试一个简单的进程调度程序,加深理解了有关进程控制块、进程队列的概念,并体会了优先权调度算法的具体实施办法。
二、实验要求用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.三、实验方法内容1.算法设计思路(流程图)开始输入所有进程到一个链表中是否所有进程都已完成结束Yi = 1,m = 0在就绪队列中找到优先级最高的进程,用P1表示,state 设为R用P2指向链表第一个节点P2所指进程state = F ?NP2所指进程state = R ?NPriority – 2,CPUTime + 1,AllTime –1,YAllTime = 0?YNState 设为F ,m = 1CPUTime % StartBlock = 0 ?state 设为B ,m = 1YNP2所指进程state = B ?BolckTime - 1BlockTime = 0?State 设为 W YYN P2所指进程state = W ?NPriority + 1YNP2指向下一个节点P2已指向链表末尾?NYM = 1 ?i <= 2 ?i + 1YNNYNY2.算法中用到的数据结构(1)首先定义一个结构体,用以保存一个进程的各种信息,最后一个指针便于将所有进程形成一个链表typedef struct pcb{int id;int arriveTime; //到达时间int priority;int cpuTime;int allTime;int startBlock;int blockTime;char state;struct pcb *next;}PCB;(2)接着建立一个链表存储所有进程,以结构体PCB为节点(头节点为空节点,从第二个节点开始存储数据)。
进程调度程序实验报告
一、实验目的通过本次实验,加深对进程调度原理和算法的理解,掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序,实现不同调度算法的模拟,并通过实验验证算法的性能。
二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法:1. 先来先服务(FCFS)2. 最短作业优先(SJF)3. 时间片轮转(RR)四、实验步骤1. 定义进程类(Process):```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类(Scheduler):```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序:```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果:");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果:");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果(时间片为2):");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验,我们可以观察到以下结果:1. FCFS调度算法简单,但可能导致长作业等待时间过长。
实验一、进程调度实验报告
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。
进程调度算法实验报告
实验报告实验一:进程调度算法一、实验目的1.利用高级语言实现三种不同及进程调度算法:短作业优先算法、时间片轮转调度算法和优先级调度算法。
2.通过实验理解有关进程控制块,进程队列等的概念。
二、实验原理各调度算法思想:1.先来先服务算法(FCFS):按照进程进入就绪队列的先后次序来分配CPU,一旦一个进程占有CPU,就一直运行下去,知道该进程完成工作,才释放CPU。
2.时间片轮转算法:系统将所有就绪进程按到达时间的先后次序排成一个队列,进程调度程序总是选择队列中的第一个进程执行,且仅能执行一个时间片,在使用完一个时间片后,即使进程并未完成其运行,也必须将CPU交给下一个进程;如果一个时间片未使用完就完成了该进程,则剩下的时间分配给下一个进程。
3.优先权调度算法;在创建进程时就确定优先权,确定之后在整个程序运行期间不再改变,根据优先级排列,系统会把CPU分配给优先权最高的进程。
三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义:PCB块结构体类型struct PCB{int name;int arrivetime; // 到达时间int servicetime; // 服务时间//int starttime[max]; // 开始时间int finishtime; // 完成/ 结束时间int turntime; // 周转时间int average_turntime; // 带权周转时间int sign; // 标志进程是否完成int remain_time; // 剩余时间int priority; // 优先级}pcb[max];主程序的流程以及各程序模块之间的层次( 调用) 关系:主程序中从键盘得到进程的数量,创建PCB,调用layout ()函数显示选择界面。
Layout ()函数中选择相应的算法并调用相关函数如:FCFS()、time_segment(); Priority() ,这三个函数分别实现先来先服务算法,时间片轮转算法和优先级算法,最后分别打印。
操作系统原理 实验一:进程调度实验报告书-模板
计算机科学系实验报告书课程名:《操作系统原理》题目:进程调度班级:学号:姓名:操作系统原理实验——进程调度实验报告一、目的与要求1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C 语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
2)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果)3)于2012年10月22日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。
2 实验内容或题目1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。
3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。
3 实验步骤与源程序实验步骤:1、理解本实验中关于两种调度算法的说明。
2、根据调度算法的说明,画出相应的程序流程图。
3、按照程序流程图,用C语言编程并实现。
源程序:#include <stdlib.h>/*进程调度优先权法*/#include <stdio.h>#include <time.h>#define null 0struct PCB{int id;int prior;int used;int need;int run;char status;struct PCB * next;};main(){struct PCB *head,*rear,*temp,*run,*small,*p,*q;int i,j,t;printf("优先权进程调度算法\n\n 5个初始进程详细信息如下:\n\n");printf("\t进程号\t优先级\tused\tneed\t状态\t下一PCB\n\n");head=null;rear=null;for(i=1;i<=5;i++) { //动态生成含5个元素的队列temp=malloc(sizeof(struct PCB)); //动态分配一个PCB temp->id=i;temp->prior=rand()%5;temp->status='W';temp->next=null;if (head==null){head=temp;rear=head;}else{rear->next=temp;rear=temp;}}temp=head;while(temp!=null){printf("\t%d\t%d\t%c\t%d\n",temp->id,temp->prior,temp->status,temp->next);temp=temp->next;}getchar(); //让程序停下来,可以查看结果。
实验一 进程调度
PCB1->name=PCB2->name;
PCB1->state=PCB2->state;
PCB1->CPU_time=PCB2->CPU_time;
}
void main()
{
InitQ();
Sleep(1000);
system("cls");
dispath();}
原始数据纪录:
试验原始数据
**************
洛阳理工学院实验报告
系别
数据科学与大数据系
班级
学号
姓名
课程名称
操作系统
实验日期
实验名称
进程调度
成绩
实验目的:
通过本次实验,加深对进程概念的理解,进一步掌握进程状态的转变及进程调度策略。
实验条件:
操作系统:Windows10
IDE:VScode
编译:gcc
实验原理:
设计程序模拟进程的时间片轮转法调度过程。假设初始状态为:有ready个进程处于就绪状态,有blocked个进程处于阻塞状态。采用轮转法进程调度算法进行调度(调度过程中,假设处于执行状态的进程不会阻塞),且每过counter个时间片,唤醒处于阻塞队列队首的进程。
deleteNode->PCB.state=1;
printf("--进程状态变为:%d\n",deleteNode->PCB.state);
counte=0;
}
}
}else
return;
}
}
void InitQ()
{
int revalrq=createQueue(&rq);
进程调度实验报告
进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。
三、实验过程。
1. 先来先服务(FCFS)调度算法。
先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。
在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。
实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。
2. 最短作业优先(SJF)调度算法。
最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。
在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。
实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。
3. 时间片轮转(RR)调度算法。
时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。
在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。
实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。
4. 多级反馈队列(MFQ)调度算法。
多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。
在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。
实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。
四、实验总结。
通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。
实验进程调度的实验报告
一、实验目的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算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。
进程的调度实验报告(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]
实验一进程调度一.实验题目:(1)、编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对五个进程进行调度。
2)、编写并调试一个模拟的进程调度程序,采用“轮转法”调度算法对五个进程进行调度。
二:实验目的用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.三.实验内容:<一>最高优先级优先调度算法1)优先级简介动态优先数是指在进程创建时先确定一个初始优先数,以后在进程运行中随着进程特性的改变不断修改优先数,这样,由于开始优先数很低而得不到CPU的进程,就能因为等待时间的增长而优先数变为最高而得到CPU运行。
例如:在进程获得一次CPU后就将其优先数减少1。
或者,进程等待的时间超过某一时限时增加其优先数的值,等等。
2)详细设计优先权调度算法:1、设定系统中有五个进程,每一个进程用一个进程控制块( PCB)表示,进程队列采用链表数据结构。
2、进程控制块包含如下信息:进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
3、在每次运行设计的处理调度程序之前,由终端输入五个进程的“优先数”和“要求运行时间”。
4、进程的优先数及需要的运行时间人为地指定.进程的运行时间以时间片为单位进行计算。
5、采用优先权调度算法,将五个进程按给定的优先数从大到小连成就绪队列。
用头指针指出队列首进程,队列采用链表结构。
6、处理机调度总是选队列首进程运行。
采用动态优先数办法,进程每运行一次优先数减“1”,同时将已运行时间加“1”。
7、进程运行一次后,若要求运行时间不等于已运行时间,则再将它加入就绪队列;否则将其状态置为“结束”,且退出就绪队列。
8、“就绪”状态的进程队列不为空,则重复上面6,7步骤,直到所有进程都成为“结束”状态。
9、在设计的程序中有输入语句,输入5个进程的“优先数”和“要求运行时间”,也有显示或打印语句,能显示或打印每次被选中进程的进程名、运行一次后队列的变化,以及结束进程的进程名。
进程调度算法 实验报告
进程调度算法实验报告
《进程调度算法实验报告》
一、实验目的
本实验旨在通过对进程调度算法的实验研究,探究不同调度算法对系统性能的影响,进一步加深对操作系统进程调度的理解。
二、实验内容
本次实验选择了三种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)和轮转调度(RR),并通过模拟不同进程的到达时间和执行时间,分别对这三种算法进行实验比较。
三、实验步骤
1. 设计实验用例:确定不同进程的到达时间和执行时间,以及不同调度算法的时间片大小。
2. 模拟执行:根据设计的实验用例,使用模拟工具模拟不同调度算法的执行过程,并记录每个进程的执行情况和系统的运行情况。
3. 数据分析:根据实验结果,对比不同调度算法的平均等待时间、平均周转时间等指标,分析各算法的优缺点。
四、实验结果
通过实验比较,得出以下结论:
1. 先来先服务(FCFS)算法:适用于执行时间较短的进程,但容易导致长作业等待时间过长。
2. 最短作业优先(SJF)算法:能够最大程度地减少平均等待时间和平均周转时间,但无法处理长作业优先的情况。
3. 轮转调度(RR)算法:能够保证每个进程都能及时得到执行,但可能导致部分进程的等待时间过长。
五、实验结论
根据实验结果,不同的进程调度算法适用于不同的场景。
在实际应用中,需要根据系统的实际情况和需求选择合适的调度算法,以最大程度地提高系统的性能和效率。
六、实验总结
通过本次实验,加深了对进程调度算法的理解,同时也了解了不同算法在实际应用中的优缺点。
希望通过本次实验,能够为进程调度算法的研究和应用提供一定的参考和借鉴。
操作系统实验——动态优先级进程调度实验报告
1.实验名称:动态优先权调度过程中就绪队列的模拟2.实验要求:采用动态优先权的进程调度算法,用C语言编程模拟调度过程中每个时间片内的就绪队列。
3.实验内容:(1)每个进程控制块PCB用结构描述,包括以下字段:*进程标识符id*进程优先数priority,并规定优先数越大的进程,其优先权越高。
*进程已占用的CPU时间cputime*进程还需占用的CPU时间alltime,当进程运行完毕时,aiitime变为0*进程的阻塞时间startblock,当进程再运行startblock个时间片后,进程将进入阻塞状态*进程被阻塞的时间blocktime,已阻塞的进程再等待blocktime个时间片后,将转换成就绪状态*进程状态state*队列指针next,将PCB排成队列。
2)调度前,系统中有五个进程,它们的初始状态如下:3)进程在就绪队列呆一个时间片,优先数增加1。
4)进程每运行一个时间片,优先数减3。
5)按下面格式显示每个时间片内就绪队列的情况:READY_QUEUE:->id1->id24.任务分析进程控制块用结构体来表示,包含它的各项属性。
建立两个队列:一个就绪队列,一个阻塞队列。
创建一个进程控制块表示当前正在运行的进程。
程序开始运行时,所有进程都在就绪队列中。
当startblock减少到0时,进程进入阻塞队列。
在阻塞队列中的进程,当blocktime减少到0时,转入就绪队列。
在就绪队列中的进程,如果优先级比当前正在执行的进程高,就可以取代当前进程获取时间片。
当前进程如果运行完毕,就绪队列中优先级最高的进程就可以成为新当前进程。
5.程序流程图#include〈iostream〉#include〈string〉usingnamespace std;#define LEN5typedefenum STATE{READYBLOCKEND}STATE;//定义进程控制块typedefstruct PCB{int id;int priority;int cputime;int alltime;int startblock;int blocktime;STATE state;}PCB;//定义队列typedefstruct queue{int si ze;PCB*data[LEN];}Queue;PCB ps[LEN];PCB*cp; //进程最大数量//进程状态//就绪//阻塞//完成//进程标识符//进程优先级//已占用的CPU时间//还需占用的CPu时间//阻塞时间//被阻塞时间//进程状态//队列中进程的数量//进程的指针//进程数组//当前正在运行的进程6.程序清单Queue rQueue,bQueue;//就绪队列和阻塞队列//就绪队列按优先级降序排序(使用了冒泡排序法)void rQueueSort(){ PCB*temp;for(int i=0;i<rQueue.size-1;i++){for(int j=0;j<rQueue.size-1-i;j++){if(rQueue.data[j]-〉priority<rQueue.data[j+1]-〉priority){temp=rQueue.data[j];rQueue.data[j]=rQueue.data[j+1];}}rQueue.dataj+1]=temp;}}//初始化void init(){//给进程赋值for(int i=0;i<LEN;i++){ps[i].id=i;ps[i].state=READY;ps[i].cputime=0;ps[i].alltime=3;ps[i].blocktime=0;ps[i].startblock=T;}ps[0].priority=9;ps[1].priority=38;ps[2].priority=30;ps[3].priority=29;ps[4].priority=0;ps[2].alltime=6;ps[4].alltime=4;ps[0].startblock=2;ps[0].blocktime=3;cp=NULL;//当前进程赋空bQueue.size=0;//阻塞队列没有进程for(int i=0;i<LEN;i++){bQueue.data[i]=NULL;rQueue.data[i]=&ps[i];}rQueue.size=5;//所有进程全部进入就绪队列rQueueSort();//对就绪队列排序}//打印void print(){cout〈〈"\nRUNNINGPROG:";if(cp!=NULL){cout〈〈cp->id;}cout<<"\nREADY_QUEUE:";for(int i=0;i<rQueue.size;i++){cout〈〈"-〉"〈〈rQueue.data[i]-〉id; }cout<<"\nBLOCK_QUEUE:";for(int i=0;i<bQueue.size;i++){cout〈〈"-〉"〈〈bQueue.data[i]-〉id; }cout〈〈"\n"<<endl;cout<<"ID\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].id<<"\t";}cout<<"\nPRI0RITY\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].priority〈〈"\t";}cout<<"\nCPUTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].cputime〈〈"\t";}cout<<"\nALLTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].alltime〈〈"\t";}cout<<"\nSTARTBLOCK\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].startblock<<"\t";}cout<<"\nBLOCKTIME\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].blocktime<<"\t";}cout<<"\nSTATE\t\t";for(int i=0;i<LEN;i++){if(ps[i].state==READY){cout<<"READY"<<"\t";}elseif(ps[i].state==BLOCK){cout<<"BLOCK"<<"\t";}elseif(ps[i].state==END){cout〈〈"END"<<"\t";}}cout〈〈endl;}//出队,返回进程指针PCB*pop(Queue*q){PCB*temp;if(q-〉size>0){temp=q-〉data[0];//取出队首进程for(int i=0;i<q-〉size-1;i++){q-〉data[i]=q-〉data[i+1];//其他进程依次向前移动}q->size__;return temp;//返回队首进程}return NULL;}//入队void push(Queue*q,PCB*p){if(q_>size<LEN){q_>data[q_〉size]=p;//将入队的进程放在队尾q_>size++;}return;}//运行进程void run(){if(rQueue.size〉0||bQueue.size〉0){if(cp==NULL){//程序一开始运行时,从就绪队列取出首进程cp=pop(&rQueue);}//当前进程没有结束,但优先级比就绪队列首进程低if(cp_〉alltime〉0&&cp_>priority<rQueue.data[0]_〉priority){}push(&r Queue,c//改变进程状态//从就绪队列取出新的当前进程//修改当前进程的状态 //将当前进程加入阻塞队列 //从就绪队列取出新的当前进程{//当前进程的startblock 为正数时//运行一次减一个时间片//减到0时,修改进程状态//每运行一个时间片//就绪队列中的进程优先级+1//每运行一个时间片//阻塞队列中的进程blocktime-1//将当前进程放入就绪队列 //就绪队列队首进程成为当前进程if (cp-〉alltime==0){cp->state =END ;cp=pop(&rQueue); }//如果当前进程运行结束//startblock 为0,标志着当前进程要进入阻塞状态if (cp —>startblock==0&&cp —>blocktime>0){cp —>state=BLOCK ; push(&bQueue,cp); cp=pop(&rQueue); }elseif (cp —>startblock>0)cp —>st artblock 一; }cp —>alltime ——;if (cp —>alltime==0){cp —>state=END ;for (int i=0;i<rQueue.size;i++){rQueue.data[i]-〉priority++; }for (int i=0;i<bQueue.size;i++){if (bQueue.data[i]-〉blocktime>0){bQueue.data[i]-〉blocktime--; }//当阻塞队列队首进程blocktime 为0时if (bQueue.size 〉0&&bQueue.data[0]-〉blocktime==0){bQueue.data[0]-〉state=READY ;//修改进程状态push(&rQueue,pop(&bQueue));//将阻塞队列首进程取出,放入就绪队列cp —〉priority-=3;//修改当前进程的优先级cp —>cputime++; //当前进程占用CPU 时间片+1 if (cp —>alltime>0){//当前进程还需运行的时间片-1}//每运行一个时间片,就绪队列排一次序rQueueSort();} }//主函数int main(){init();//初始化 print();//打印进程信息 while (1){_sleep(1000);if (rQueue.size==0&&bQueue.size==0){//当两个队列都为空时,结束程序cp-〉state=END ;break ; }run();//运行进程 print();//打印进程信息 }return 0; }7.实验过程记录m 匚:\WINDQWS\system32\cmd.exe程序开始执行,当前进程是优先级最高的1号进程,1号进程的优先级减3、cputime++、执行几次之后,1号进程执行完毕而且优先级也不是最高的了,所以优先级为33的2号进程成为当前进程,开始执行。
模拟调度实验报告(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算法根据进程的优先级进行调度,优先级高的进程优先执行。
具体实现如下:- 设置一个优先级阈值,当进程的优先级高于阈值时,将其加入就绪队列。
- 遍历就绪队列,选择优先级最高的进程执行,直到进程完成或被阻塞。
实验一:进程调度实验报告书
淮海工学院计算机工程学院实验报告书课程名:《操作系统原理A》题目:进程调度班级:软件132学号: 07姓名:孙莹莹操作系统原理实验——进程调度实验报告一、目的与要求1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C 语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
2)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果)3)于2015年4月18日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。
二、实验内容或题目1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。
3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。
三、实验步骤与源程序(1)流程图(2)实验步骤1)PCB的结构:优先级算法中,设PCB的结构如下图所示,其中各数据项的含义如下:Id:进程标识符号,取值1—5。
Priority:优先级,随机产生,范围1—5。
Used:目前已占用的CPU时间数,初值为0;当该进程被调用执行时,每执行一个时间片,Used 加1。
Need:进程尚需的CPU时间数,初值表示该进程需要运行的总时间,取值范围为5—10。
并随机产生,每运行一个时间片need减1;need为0则进程结束。
Status:进程状态R(运行),W(就绪),F(完成);初始时都处于就绪状态。
Next:指向就绪队列中下一个进程的PCB的指针。
2)初始状态及就绪队列组织:5个进程初始都处于就绪状态,进程标识1—5,used初值都为0。
各进程的优先级随机产生,范围1—5。
处于就绪状态的进程,用队列加以组织,队列按优先级由高到低依次排列,队首指针设为head,队尾指针为tail。
进程调度实验报告答案(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,插入到就绪队列相关位置。
分析:动态优先级调度算法能够根据进程的运行情况动态调整优先级,使得优先级高的进程能够得到更多的运行时间,从而提高系统的响应速度。
实验一:进程调度实验报告书
实验一:进程调度实验报告书淮海工学院计算机科学系实验报告书课程名:《操作系统原理》题目: 进程调度班级: 网络091学号: 110912133姓名: 钟学圣评语:成绩: 指导教师:批阅时间: 年月日《操作系统原理》实验报告 - 1 -操作系统原理实验——进程调度实验报告一、目的与要求1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关2实验数据与运行结果)3)于2011年10月22日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。
2 实验内容或题目1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。
3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。
3 实验步骤与源程序(1) 编写进程控制块数据结构typedef struct node{char name[10];/*进程名*/int prio; /*进程优先级*/int round; /*循环轮转法进程每次轮转的时间片*/int cputime; /*进程累计消耗的CUP时间*/int needtime; /*进程到完成还需要的CUP时间*/int count; /*循环轮转法一个是时间片内进程运行时间*/char state; /*进程的状态:'R':运行,'W':等待,'F':结束*/struct node *next;/*指向下一个进程的链指针*/}PCB;(2)在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中void prior_init(char chose)/*进程优先级法初始化将进程按优先级插入到就绪队列里*/{PCB *p;int i,time1;char na[10];ready=NULL;finish=NULL;run=NULL;《操作系统原理》实验报告 - 2 -printf("\t\t进程优先级算法模拟全过程\n\n");printf("输入进程的个数 N:\n");scanf("%d",&N); for(i=0;i<N;i++)(3)进程优先级法初始化将进程按优先级插入到就绪队列里void prior_init(char chose)/*进程优先级法初始化将进程按优先级插入到就绪队列里*/ {PCB *p;int i,time1;char na[10];ready=NULL;finish=NULL;run=NULL;printf("\t\t进程优先级算法模拟全过程\n\n");printf("输入进程的个数 N:\n");scanf("%d",&N); for(i=0;i<N;i++)(4)进程优先级算法总函数void priority(char chose)//进程优先级算法总函数 { int i=1;while(run!=NULL){run->cputime+=1;run->needtime-=1;run->prio-=1;if(run->needtime==0){run->next=finish;finish=run;run->state='F';run->prio=0;run=NULL;firstin(); }else{if((ready!=NULL)&&(run->prio<ready->prio)) {run->state='W';insert_prio(run);run=NULL;firstin();}《操作系统原理》实验报告 - 3 -}详细代码:#include <stdio.h>#include <stdlib.h>#include <string.h>#include <windows.h>#include <time.h>/*进程控制块数据结构*/typedef struct node{char name[10];/*进程名*/int prio; /*进程优先级*/int round; /*循环轮转法进程每次轮转的时间片*/ int cputime; /*进程累计消耗的CUP时间*/int needtime; /*进程到完成还需要的CUP时间*/int count; /*循环轮转法一个是时间片内进程运行时间*/ char state; /*进程的状态:'R':运行,'W':等待,'F':结束*/ struct node *next;/*指向下一个进程的链指针*/ }PCB;PCB *finish,*ready,*tail,*run;/*指向三个队列的队首的指针,finish为完成队列头指针,ready为就绪队列头指针,tail为就绪队列的队尾指针,run为当前运行进程头指针*/int N;/*定义进程的数目*/void firstin(void); //调度就绪队列的第一个进程投入运行; voidprint1(char a); //打印表头行信息void print2(char chose,PCB *p); //打印每一行的状态信息 voidprint(char chose); //打印每执行一次算法后所有的进程的状态信息 void insert_prio(PCB *q); //在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中;void prior_init(char chose); //进程优先级法初始化将进程按优先级插入到就绪队列里void priority(char chose); //进程优先级算法总函数 void insert_rr(PCB *q); //在轮转法中,将执行了一个时间片单位(为2),但尚未完成的进程的PCB,插到就绪队列的队尾;void roundrun_init(char chose); //循环轮转法初始化将就绪队列保存为FIFO队列void roundrun(char chose); //循环轮转法总算法void main()//主函数{char chose=' ';《操作系统原理》实验报告 - 4 -while((chose!='e')&&(chose!='E')){fflush(stdin);system("cls");printf("\t\t\t两种进程调度算法的模拟\n\n");printf("\tP.进程优先级算法模拟\n\n"); printf("\tR.循环轮转算法模拟\n\n"); printf("\tE.推出程序\n\n");printf("\t请输入你的选择:");scanf("%c",&chose);if((chose!='e')&&(chose!='E')){system("cls");if((chose=='P')||(chose=='p')){prior_init(chose);priority(chose);system("cls");}else if((chose=='r')||(chose=='R')) {roundrun_init(chose);roundrun(chose);system("cls");}}}printf("\n\t\t谢谢使用~~~\n");}void firstin(void)//调度就绪队列的第一个进程投入运行; { if(ready!=NULL){run=ready;ready=ready->next;run->state='R';run->next=NULL;}else《操作系统原理》实验报告 - 5 -{run=NULL;}}void print1(char a)//打印表头行信息{if(toupper(a)=='P'){printf("name cputime needtime priority state \n");}else{printf("name cputime needtime count round state \n"); }}void print2(char chose,PCB *p)//打印每一行的状态信息 {if(toupper(chose)=='P') {printf("%s\t%d\t%d\t%d\t %c\n",p->name,p->cputime,p->needtime,p->prio,p->state);}else{printf("%s\t%d\t%d\t%d\t%d\t%c\n",p->name,p->cputime,p->needtime,p->count,p->round,p->state);}}void print(char chose)//打印每执行一次算法后所有的进程的状态信息{PCB *p;print1(chose);if(run!=NULL){print2(chose,run);}p=ready;while(p!=NULL){print2(chose,p);p=p->next;}《操作系统原理》实验报告 - 6 -p=finish;while(p!=NULL){print2(chose,p);p=p->next;}}void insert_prio(PCB *q)/*在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中;*/ {PCB *p,*s,*r; /*p,r用来控制就绪队列滚动,S指向插入的队列*/s=q;p=ready;r=p;if(s->prio>ready->prio)// 要插入的进程的优先级大于ready的优先级{s->next=ready;ready=s;}else//要插入的进程的优先级不大于ready的优先级 {while(p){if(p->prio>=s->prio) {r=p;p=p->next;}elsebreak;} //找到要插入的位置s->next=p;r->next=s;}}void prior_init(char chose)/*进程优先级法初始化将进程按优先级插入到就绪队列里*/ {PCB *p;int i,time1;char na[10];ready=NULL;《操作系统原理》实验报告 - 7 -finish=NULL;run=NULL;printf("\t\t进程优先级算法模拟全过程\n\n"); printf("输入进程的个数 N:\n");scanf("%d",&N); for(i=0;i<N;i++){p=(PCB*)malloc(sizeof(PCB));printf("输入第%d个进程名\n",i+1); scanf("%s",na);printf("完成进程需要的时间片数\n"); scanf("%d",&time1); strcpy(p->name,na); p->cputime=0;p->needtime=time1; p->state='W';srand((unsigned)time(NULL));//用当前时间,设置种子int ss=1+rand()%6; p->prio=ss;//设置进程优先值初值if(ready==NULL){ready=p;ready->next=NULL; }else{insert_prio(p); }printf("当前就绪队列的进程的信息\n"); print(chose);}printf("%d个进程已按优先级从高到低进到就绪队列中\n",N);printf("按回车键开始模拟优先级算法.....\n");fflush(stdin);getchar();firstin();}void priority(char chose)//进程优先级算法总函数 {int i=1;while(run!=NULL){run->cputime+=1;《操作系统原理》实验报告 - 8 -run->needtime-=1;run->prio-=1;if(run->needtime==0) {run->next=finish;finish=run;run->state='F';run->prio=0;run=NULL;firstin(); }else{if((ready!=NULL)&&(run->prio<ready->prio)) {run->state='W';insert_prio(run);run=NULL;firstin();}}printf("第%d次执行优先级算法\n",i++);print(chose);if(run){printf("按回车键继续下一次优先级算法.....\n");}elseprintf("优先级算法模拟过程结束~~\n");fflush(stdin);getchar();}}void insert_rr(PCB *q)//在轮转法中,将执行了一个时间片单位(为2),//但尚未完成的进程的PCB,插到就绪队列的队尾; {tail->next=q;tail=q;q->next=NULL;}void roundrun_init(char chose)/*循环轮转法初始化将就绪队列保存为FIFO队列*/《操作系统原理》实验报告 - 9 -{PCB *p;int i,time1;char na[10];ready=NULL;finish=NULL;run=NULL;printf("\t\t循环轮转算法模拟全过程\n\n");printf("输入进程的个数 N:\n");scanf("%d",&N); for(i=0;i<N;i++){p=(PCB*)malloc(sizeof(PCB));printf("输入第%d个进程名\n",i+1); scanf("%s",na);printf("完成进程需要的时间片数\n"); scanf("%d",&time1); strcpy(p->name,na); p->cputime=0;p->needtime=time1; p->count=0;p->state='W';p->round=2;if(ready!=NULL){insert_rr(p);}else{p->next=ready;ready=p;tail=p;}printf("当前就绪队列的进程的信息\n"); print(chose); }printf("%d个进程已按FIFO进到就绪队列中\n",N); printf("按回车键开始模循环轮转算法.....\n");fflush(stdin);getchar();run=ready;ready=ready->next; run->state='R';}void roundrun(char chose)//循环轮转法总算法《操作系统原理》实验报告 - 10 -{int i=1;while(run!=NULL){run->cputime+=1;run->needtime-=1; run->count+=1;if(run->needtime==0) {run->next=finish;finish=run;run->state='F';run->prio=0;run=NULL;if(ready!=NULL){firstin();}}else{if(run->count==run->round){run->count=0;if(ready!=NULL){run->state='W';insert_rr(run);firstin();}}}printf("第%d次执行循环轮转算法\n",i++);print(chose);if(run){printf("按回车键继续下一次循环轮转算法.....\n"); }elseprintf("循环轮转算法模拟过程结束~~\n"); fflush(stdin);getchar();}}《操作系统原理》实验报告 - 11 -4 测试数据与实验结果(可以抓图粘贴)一、使用优先级实现进程调度1. 输入以下数据,并且随机产生1—5优先级2.按回车开始模拟优先级算法《操作系统原理》实验报告 - 12 - 3.运行结果二、时间片轮转算法1. 输入以下数据2. 开始模拟运行《操作系统原理》实验报告 - 13 - 3. 运行结束5 结果分析与实验体会经检查,所运行结果正确。
操作系统实验之进程调度报告
实验一:进程调度一、实习内容1.模拟批处理多道操作系统的进程调度;2.模拟实现同步机构避免并发进程执行时可能与时间相关的错误;二、实习目的进程调度时进程管理的主要内容之一,通过设计,编制,调试一个简单的进程调度模拟系统,对进程调度,进程运行状态变换及PV操作加深理解和掌握。
三、实习题目采用剥夺式优先算法,对三个进程进行模拟调度模拟PV操作同步机构,用PV操作解决进程进入临界区的问题。
【提示】(1)对三个进程进行模拟调度,对各进程的优先数静态设置,P1,P2,P3三个进程的优先数为1,2,3,并指定P1的优先数最高,P3的优先数最低,每个进程都处于执行态“e”,就绪态“r”,等待态“w”三种状态之一,并假定初始态为“r”。
(2)每一个进程用一个PCB表,PCB表的内容根据具体情况设置,该系统在运行过程中能显示或打印各进程和参数的变化情况,以便观察各进程的调度。
(3)在完成必要的初始化后,便进入进程调度程序,首先由P1进入执行,当执行进程因等待某各事件被阻塞或唤醒某个进程等待进程时,转进程调度。
(4)在进入临界区前后,调PV操作。
(5)如果被唤醒的进程优先数高于现有执行的进程,则剥夺现行进程的执行权。
(6)当三个进程都处于等待状态时,本模拟系统退出执行。
四、示例1.数据结构:(1)进程控制块PCBstruct{int id;char status;int priority;int waiter1;}(2)信号量struct{int value;int waiter2;}sem[2](3)现场保护栈stackchar stack[11][4]每个进程都有一个大小为10个字的现场保护栈,用来保护被中断时的断点地址等信息。
(4)全局变量int i;用以模拟一个通用寄存器char addr;用以模拟程序计数器int m1,m2;为系统设置的公用数据被三个进程共享使用。
五、程序框图:六、程序说明:本程序是用C语言编写,模拟三个进程的运行情况,过程在运行中要调用P操作申请信号量,如果该过程得到其申请的信号量,就继续运行,否则P操作阻塞该申请过程的运行,并将过程置为所申请信号量的等待者,如果已有其它过程在等待同一信号量则将该申请过程排在所有等待进程之后。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
淮海工学院计算机工程学院实验报告书
课程名:《操作系统原理A》
题目:进程调度
班级:软件132
学号:2013122907
姓名:孙莹莹
操作系统原理实验——进程调度实验报告
一、目的与要求
1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C 语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
2)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果)
3)于2015年4月18日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。
二、实验内容或题目
1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。
3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。
三、实验步骤与源程序
(1)流程图
(2)实验步骤
1)PCB的结构:优先级算法中,设PCB的结构如下图所示,其中各数据项的含义如下:
Id:进程标识符号,取值1—5。
Priority:优先级,随机产生,范围1—5。
Used:目前已占用的CPU时间数,初值为0;当该进程被调用执行时,每执行一个时间片,Used加1。
Need:进程尚需的CPU时间数,初值表示该进程需要运行的总时间,取值范围为5—10。
并随机产生,每运行一个时间片need减1;need为0则进程结束。
Status:进程状态R(运行),W(就绪),F(完成);初始时都处于就绪状态。
Next:指向就绪队列中下一个进程的PCB的指针。
2)初始状态及就绪队列组织:
5个进程初始都处于就绪状态,进程标识1—5,used初值都为0。
各进程的优先级随机产生,范围1—5。
处于就绪状态的进程,用队列加以组织,队列按优先级由高到低依次排列,队首指针设为head,队尾指针为tail。
3)调度原则以及运行时间的处理:
正在执行的进程每执行一个时间片,其优先级减1(允许优先级为负)。
进程调度将在以下情况发生:当正在运行的程序其优先级小于就绪队列队首进程的优先级时。
程序中进程的运行时间以逻辑时间片为单位。
RUN ----当前运行进程指针;
HEAD──就绪进程队列的PCB链链首指针;
TAIL──就绪进程队列的PCB链链尾指针;
(3)源程序
#include"stdio.h"
#include"conio.h"
#include"stdlib.h"
#include<ctime>
typedef struct pcb
{
int id;//进程ID
int prior;//进程优先级
int used;//已使用的时间片
int need;//还需要的时间片
char status;//进程状态
}PCB;
PCB *head,p[5];
//打印显示
void print()
{
printf("--------------------------------------------------\n");
printf("进程ID\t优先级\t已使用时间片\t所需时间片\t状态\n");
for(int j = 0; j < 5; j++)
{
if(p[j].id>p[j+1].id)
{
int temp1;
temp1=p[j].id;
p[j].id=p[j+1].id;
p[j+1].id=temp1;
printf("%d\t %d\t %d\t\t %d\t\t%c\n
",p[j].id,p[j].prior,p[j].used,p[j].need,p[j].status);
}
}
//用冒泡算法,按优先级排序
void sort()
{
for(int i = 0; i < 5; i++)
for(int j = 0; j < 4 - i; j++)
if(p[j].prior < p[j+1].prior)
{
PCB temp = p[j];
p[j] = p[j+1];
p[j+1] = temp;
}
}
//初始化进程队列
void inputprocess()
{
srand(time(0));//为随机数产生种子
//依次为每个P[i]初始化
for(int i=0; i<5; i++)
{
p[i].id = i + 1;
p[i].prior = 5-i;//为优先级随机产生1 - 5 的整数
p[i].used = 0;
p[i].need = 5 + rand()%6;//为总的时间片产生5 - 10 的整数p[i].status = 'W';//各个进程的初始状态为就绪
}
sort();//按优先级排序
head = p;
printf("开始进程的状态:\n");
print();//打印进程状态
}
//按最高优先级优先调用进程队列
void runprocess()
PCB *p1 = NULL;
do
{
p1 = head;
head = p+1;
//根据优先级调度原则,判断队列队首进程是否能运行
while((p1->need > 0) && (p1->prior >= head->prior))
{
p1->need--;
p1->prior--;
p1->status = 'R';
p1->used++;
print();//打印进程状态
}
//如果进程总的时间片已经用完,一律将其进程优先级置为-20,状态为完成
if(p1->need == 0)
{
p1->prior = -20;
p1->status = 'F';
}
else
p1->status = 'W';
sort();//再次排序为下一次的运行做好准备
head = p;
}
while(head->prior != -20);
print();//显示最后各个进程的状态
printf("----------------------------------------------\n");
printf("所有进程已全部完成.");
}
int main()
{
inputprocess();//调用初始化进程自定义函数
runprocess();//调用调度进程的函数
return(1);
}
四、测试数据与实验结果(可以抓图粘贴)
五、结果分析与实验体会
虽然实验原理很简单,但是在编写代码的过程中遇到了不少的问题,在两个小时之内已经完成的大体代码的编写,但是之中存在不少的问题,导致了用了差不多四个小时的时间去调试才把它弄好,这主要归咎于在开始设计代码的不太合理,在后期使得代码结构有些混乱,使得调试更加的麻烦,以及对编程的不熟悉。
通过这个实验不仅使我对进程的调度算法有了更深的认识,使得理论知识得到的实践,也使我的编程能力得到了进一步提高。