计算机操作系统CPU的调度程序实验报告

合集下载

计算机操作系统-处理机调度实验报告(精品)

计算机操作系统-处理机调度实验报告(精品)

中南大学实验名称:处理机调度课程名称:计算机操作系统学生姓名盛希玲学号 ********** 学院信息科学与工程学院专业班级电子信息工程0602 完成时间 2008年10月12日目录一实验内容 (2)二实验目的 (2)三实验题目 (2)四基本思想 (2)五算法分析 (2)六流程图 (3)七算法描述 (4)八运行输出结果 (9)一实验内容选择一个调度算法,实现处理机调度。

二实验目的多道系统中,当就绪进程数大于处理机数时,须按照某种策略决定哪些进程优先占用处理机。

本实验模拟实现处理机调度,以加深了解处理机调度的工作。

三实验题目设计一个按优先权调度和时间片轮转算法实现处理机调度的程序。

四基本思想先选择时间片的个数和每个时间片需要的时间,正在运行的进程每运行一秒其优先权数目加一,即其优先权减小。

每个时间片运行结束后,选择进入时间片进程优先权数目最小的进程,开始下一个时间片的运行。

如果有进程运行结束,则离开,再在就绪队列中选择优先权数目最小的进程进入。

在运行期间,如果有新的进程来到,按优先权大小放入就绪队列中。

五算法分析定义一个结构体,此包含了PCB的信息:struct PCB{char PID[5]; /*进程名*/int needtime; /*要求运行的时间*/int cputime; /*已运行时间*/int priority; /*优先权(越小越高)*/int starttime; /*进入就绪队列的时间*/int overtime; /*运行完成的时间*/int state; /*状态:1就绪2运行3完成*/struct PCB *next;};子函数struct PCB *create(int num,int n)用来建立一个按优先级大小排列的就绪进程链表和一个按时间先后循序排列的将进入就绪进程的链表。

main()函数中用一while循环输出进入时间片的进程状态。

六流程图七算法描述#define NULL 0#define LEN sizeof(struct PCB)#include"stdio.h"#include"stdlib.h"struct PCB{char PID[5]; /*进程名*/int needtime; /*要求运行的时间*/int cputime; /*已运行时间*/int priority; /*优先权(越小越高)*/int starttime; /*进入就绪队列的时间*/int overtime; /*运行完成的时间*/int state; /*状态:1就绪2运行3完成*/struct PCB *next;};struct PCB *create(int num,int n)/*创建进程,并将进程按优先级顺序插入队列中*/ {struct PCB *head,*p,*p1,*p2;int i;head=NULL; /*头指针指零*/for(i=1;i<=num;i++) /*循环建立所有进程*/{printf("请输入第%d个进程的信息\n",i);p=(struct PCB *)malloc(LEN); /*开辟一个空间*/printf("进程名:"); /*输入进程名*/scanf("%s",p->PID);printf("要求运行的时间:"); /*输入要运行的时间*/scanf("%d",&p->needtime);p->cputime=0; /*占用处理机的时间赋为零*/printf("优先权:"); /*输入优先权*/scanf("%d",&p->priority);if(n==1)p->starttime=0; /*进入就绪队列的时间赋为零*/else{printf("进入就绪队列时间:"); /*输入进入就绪队列的时间*/scanf("%d",&p->starttime);}p->overtime=-1; /*运行没有结束所以运行完成的时间赋为-1*/p->state=1; /*状态赋为就绪状态*/p1=head; /*p1指针指向头指针*/if(head==NULL) /*如果头指针为零将头指针指向新建立的进程*/ {head=p;head->next=NULL;}else /*头指针不为零的情况*/{if(n==1)while(p1!=NULL&&p->priority>p1->priority) /*查找插入点*/{p2=p1;p1=p1->next;}elsewhile(p1!=NULL&&p->starttime>p1->starttime) /*查找插入点*/{p2=p1;p1=p1->next;}if(head==p1) /*优先权的值最小作为表头*/{p->next=head;p2=head=p;}else /*否则的话插入*/{p2->next=p;p->next=p1;}}}return(head);}void main(){char now[5];int cho,num,num1,timepiece,time,i,j,k,flag,choo,clock=0;struct PCB*head,*head1,*over,*later,*l,*l1,*l2,*p,*p0,*p1,*p2,*q,*q1,*q2,*q3;over=NULL;printf("初始化进程...\n");printf("输入总的就绪进程数:");scanf("%d",&num);head=create(num,1); /*建立就绪进程的链表*/printf("输入将会就绪的进程数:");scanf("%d",&num1); /*建立将会进入就绪进程的链表*/later=create(num1,2);printf("cpu是否开始运行:1是 2不是--");scanf("%d",&cho);if(cho==1) /*处理机开始进行调度*/{printf("现在的时间是:");scanf("%s",now);printf("显示所有就绪的进程:\n");p2=head;printf("进程名\t要求运行时间\t已运行时间\t优先权\t状态(1就绪2运行3结束)\n");while(p2!=NULL){printf("%s\t%d\t\t%d\t\t%d\t%d\n",p2->PID,p2->needtime,p2->cputime ,p2->priority,p2->state);p2=p2->next;}printf("请输入时间片总数:");scanf("%d",&timepiece);printf("请输入时间片的时间:");scanf("%d",&time);printf("运行正式开始!\n");head1=head;printf("\t\t进程名\t要求运行时间\t已运行时间\t优先权\t状态\n"); for(i=1;i<=timepiece;i++) /*将进入时间片运行的进程用头指针head1指示,并改变就绪进程头指针head的指向*/{if(head!=NULL){p=head;head=head->next;}else break;}p->next=NULL;while(head1!=NULL) /*就绪进程头指针不为零就循环*/{head1->state=2; /*状态:1就绪2运行3完成*/for(j=1;j<=time;j++) /*每个时间片所需时间的循环*/{clock++; /*定时器每秒加1*/if(later!=NULL&&clock==later->starttime)/*如果将进入就绪队列的进程时间到达加入就绪队列*/ {l=later;l1=head;later=later->next;if(head==NULL){head=l;head->next=NULL;}else{while(l1!=NULL&&l1->priority<=l->priority){l2=l1;l1=l1->next;}if(l1==head){l->next=head;head=l;}else{l2->next=l;l->next=l1;}}}flag=0;printf("\n%3d秒时间片第%d秒 ",clock,j);q=head1;if(head1->needtime>head1->cputime) /*以运行时间和优先权都加1*/ {head1->cputime++;head1->priority++;while(q) /*运行队列不为零输出其信息*/ {if(q==head1)printf("%s\t%d\t\t%d\t\t%d\t%d\n",q->PID,q->needtime,q->cputime,q->pr iority,q->state);elseprintf("\t\t %s\t%d\t\t%d\t\t%d\t%d\n",q->PID,q->needtime,q->cputim e,q->priority,q->state);q=q->next;}}if(head1->needtime==head1->cputime)/*运行完成将其放入over为头指针的链表中*/ {head1->state=3;head1->overtime=clock;if(over==NULL){over=head1;head1=head1->next;over->next=NULL;}elseif(over!=NULL&&head1!=NULL){p1=head1->next;p0=over;over=head1;over->next=p0;head1=p1;}flag=1;}if(flag==1) break;}if(flag==1) /*有进程结束的情况*/{if(head!=NULL) /*就绪队列不为零将优先权最高的放入运行链表中*/ {q1=head;head=head->next;q2=head1;while(q2!=NULL&&q2->priority<=q1->priority){q3=q2;q2=q2->next;}if(q2==head1){q1->next=head1;head1=q1;}else{q3->next=q1;q1->next=q2;}}}else /*无进程结束的情况,寻找优先权最高的运行*/{head1->state=1;q1=head1;head1=head1->next;q2=head1;while(q2!=NULL&&q2->priority<=q1->priority){q3=q2;q2=q2->next;}if(q2==head1){q1->next=head1;head1=q1;}else{q3->next=q1;q1->next=q2;}}}}printf("cpu结束运行!\n");printf("是否输出所有结束的进程:1是2不是--");scanf("%d",&choo);if(choo==1) /*输出所有完成运行的进程*/{printf("开始时间:%s\n",now);printf("进程名\t要求运行时间\t进入就绪队列的时间\t运行完成的时间\n");while(over!=NULL){printf("%s\t%d\t\t%d\t\t\t%d\n",over->PID,over->needtime,over->startt ime,over->overtime);over=over->next;}}}八运行输出结果初始化进程如右图显示现在的时间和所有就绪的进程输入时间片的总数和每个时间片的时间运行时显示的信息。

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

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

计算机操作系统进程调度实验报告实验报告:计算机操作系统进程调度1.实验背景与目的计算机操作系统是一种负责管理和协调计算机硬件和软件资源的系统。

进程调度作为操作系统的重要功能之一,主要负责决定哪些进程可以运行、何时运行以及运行多长时间等问题。

本实验旨在通过实践学习进程调度的原理和实现细节,加深对操作系统的理解。

2.实验原理与步骤(1)实验原理:进程调度的目标是充分利用计算机资源,提高系统的吞吐率和响应时间。

常用的调度算法有先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)等。

在本实验中,我们将实现时间片轮转调度算法,并对比不同算法的性能差异。

(2)实验步骤:1)设计进程数据结构:创建进程控制块(PCB)结构体,包含进程的标识符、到达时间、服务时间、剩余时间、等待时间等信息。

2)生成进程:根据指定的进程个数和服务时间范围,生成随机的进程并初始化进程控制块。

3)时间片轮转调度算法:根据时间片大小,按照轮转调度的方式进行进程调度。

4)性能评估:通过记录进程的等待时间和周转时间,比较不同调度算法的性能差异。

3.实验结果与分析通过实验我们生成了10个进程,并使用时间片大小为2进行轮转调度。

下表列出了各个进程的信息及调度结果。

进程到达时间服务时间剩余时间等待时间周转时间P108068P214004P3291310P4350115P542032P6570147P763063P8761714P981071P1093104从实验结果可以看出,时间片轮转调度算法相对公平地分配了CPU给各个进程,减少了等待时间和周转时间。

但是,对于长时间服务的进程,可能出现饥饿问题,即一些耗时较长的进程无法得到充分的CPU时间。

与时间片轮转算法相比,先来先服务(FCFS)算法对于短作业具有更好的响应时间,但可能导致长作业等待时间过长。

最短作业优先(SJF)算法能够最大化短作业的优先级,提高整体性能。

4.实验总结与体会本次实验通过实践了解了进程调度的原理与实现细节,加深了对操作系统的理解。

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

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

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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)和时间片轮转(RR)。

1. 实验准备
在开始实验之前,我们首先搭建了一个简单的模拟环境,包括一个CPU和多个进程。

每个进程具有不同的执行时间,以便模拟不同情况
下的调度效果。

2. 先来先服务(FCFS)
先来先服务是最简单的调度算法之一,即根据进程到达的顺序依次
执行。

实验结果显示,FCFS算法适用于处理大量长作业,但当出现短
作业时会导致平均等待时间较长。

3. 最短作业优先(SJF)
最短作业优先算法会优先执行执行时间最短的进程,以减少平均等
待时间。

在我们的实验中,SJF算法表现出色,尤其在短作业较多的情
况下,能够显著提高系统的响应速度。

4. 时间片轮转(RR)
时间片轮转算法将CPU时间分配给每个进程,每个进程执行一个
时间片后轮转到下一个进程。

然而,RR算法可能导致上下文切换频繁,
影响系统效率。

在实验中,我们发现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. 背景处理器调度算法是操作系统中的重要组成部分,用于优化多道程序在处理器上的执行顺序,提高系统的整体性能和响应时间。

通过合理的调度算法,可以使多个进程公平竞争处理器资源,并满足不同进程的优先级要求。

本次实验旨在探究不同的处理器调度算法在不同场景下的效果,以及调度算法对系统性能的影响。

2. 分析2.1 实验环境本次实验使用模拟器搭建了一个简化的多道程序系统,包含多个进程和一个处理器。

每个进程具有不同的优先级和执行时间。

调度算法的任务是按照一定的规则将进程调度到处理器上执行。

2.2 调度算法本次实验采用了三种常见的调度算法进行比较:先来先服务调度(FCFS)、最短作业优先调度(SJF)和时间片轮转调度(RR)。

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

该算法简单直观,但无法考虑进程的执行时间,可能导致长作业优先问题。

•SJF算法:按照进程的执行时间进行调度,先执行执行时间较短的进程。

该算法可以减少平均等待时间,但是对长作业不公平。

•RR算法:将进程按照到达顺序排成一个队列,每个进程执行一小段时间片后,切换到下一个进程。

该算法可以公平地分配处理器资源,但是可能导致上下文切换频繁。

2.3 实验设计本次实验设计了多个场景,每个场景包含一组具有不同优先级和执行时间的进程。

在每个场景中,分别使用FCFS、SJF和RR算法进行调度,并记录每个进程的等待时间和周转时间。

2.4 实验结果经过实验统计和数据分析,得到了每个场景下不同调度算法的各项指标,如下表所示:实验场景算法平均等待时间平均周转时间场景1 FCFS 10 20场景1 SJF 5 15场景1 RR 8 18场景2 FCFS 15 25场景2 SJF 5 15场景2 RR 12 22…………2.5 结果分析从上表可以看出,不同的调度算法在不同场景下表现出了不同的性能。

具体分析如下:•FCFS算法在长作业的场景中表现较差,平均等待时间和平均周转时间较长。

进程的调度实验报告(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. 理解处理器调度的基本概念和原理;2. 掌握常用的处理器调度算法,如先来先服务(FCFS)、短作业优先(SJF)、优先级调度等;3. 分析不同调度算法的性能指标,如平均周转时间、平均带权周转时间等;4. 通过实验,提高实际操作和编程能力。

二、实验原理处理器调度是操作系统中的一个重要组成部分,其主要任务是合理分配处理器资源,使系统中的多个进程高效、有序地运行。

常见的处理器调度算法有以下几种:1. 先来先服务(FCFS):按照进程到达就绪队列的顺序进行调度,先到先服务;2. 短作业优先(SJF):优先选择运行时间最短的进程执行;3. 优先级调度:根据进程的优先级进行调度,优先级高的进程先执行;4. 时间片轮转(RR):将每个进程分配一个时间片,按照时间片轮转的方式调度进程。

三、实验内容1. 实验环境:Windows操作系统,Python编程语言;2. 实验工具:Python编程环境,如PyCharm、Spyder等;3. 实验步骤:(1)设计一个进程类,包含进程名、到达时间、运行时间、优先级等属性;(2)编写调度算法,实现FCFS、SJF、优先级调度和时间片轮转算法;(3)模拟进程执行过程,记录各个进程的执行时间、等待时间、周转时间等性能指标;(4)分析不同调度算法的性能,比较其优劣。

四、实验结果与分析1. FCFS调度算法实验结果:平均周转时间为20,平均带权周转时间为1.25。

分析:FCFS调度算法简单易实现,但可能导致进程响应时间长,不利于实时性要求高的系统。

2. SJF调度算法实验结果:平均周转时间为16,平均带权周转时间为1.2。

分析:SJF调度算法可以缩短平均周转时间,提高系统性能,但可能使长作业长时间等待,影响公平性。

3. 优先级调度算法实验结果:平均周转时间为18,平均带权周转时间为1.3。

分析:优先级调度算法可以根据进程的优先级进行调度,提高系统响应速度,但可能导致低优先级进程长时间等待。

处理器调度实验报告

处理器调度实验报告

处理器调度实验报告处理器调度实验报告一、实验目的处理器调度是操作系统中的重要组成部分,它负责决定哪个进程优先执行,以及如何分配处理器资源。

本次实验旨在通过模拟不同的处理器调度算法,深入了解各种算法的工作原理和优缺点。

二、实验背景在多道程序设计环境下,多个进程同时竞争有限的处理器资源。

为了提高系统的吞吐量和响应速度,需要合理地调度进程,使得每个进程都能得到公平的执行机会。

处理器调度算法的选择直接影响到系统的性能和用户体验。

三、实验内容本次实验使用模拟器来模拟不同的处理器调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和优先级调度(Priority Scheduling)。

通过对这些算法的模拟实验,我们可以观察到它们在不同场景下的表现。

四、实验过程与结果首先,我们设计了一组测试用例,每个测试用例包含若干个进程,每个进程具有不同的执行时间和优先级。

然后,我们分别使用不同的调度算法对这些进程进行调度,并记录下每个进程的等待时间和周转时间。

在FCFS算法下,进程按照到达的先后顺序依次执行。

这种算法简单直观,但是容易造成后面进程的等待时间过长,尤其是当某个进程执行时间较长时。

SJF算法根据进程的执行时间来进行调度,执行时间最短的进程先执行。

这种算法能够最大程度地减少平均等待时间,但是对于长作业来说,可能会出现饥饿现象。

RR算法将处理器的时间划分为若干个时间片,每个进程在一个时间片内执行一定的时间,然后切换到下一个进程。

这种算法能够保证每个进程都能得到执行的机会,但是对于执行时间较长的进程来说,可能会造成较大的上下文切换开销。

优先级调度算法根据进程的优先级来进行调度,优先级高的进程先执行。

这种算法可以根据不同的场景进行调整,但是可能会出现优先级反转的问题。

通过实验结果的分析,我们可以看到不同的调度算法在不同场景下的表现。

对于短作业来说,SJF算法能够最大程度地减少等待时间;对于长作业来说,RR算法能够保证公平性;而优先级调度算法则适用于一些需要特定优先级处理的场景。

处理机调度实验报告

处理机调度实验报告

处理机调度实验报告处理机调度实验报告引言:处理机调度是操作系统中的重要组成部分,它负责决定在多道程序环境下,哪个进程应该获得处理机的使用权。

本实验旨在通过模拟处理机调度算法,探索不同调度算法对系统性能的影响,并对其进行评估和比较。

实验设计:在本实验中,我们选择了三种常见的处理机调度算法,分别是先来先服务调度(First-Come, First-Served, FCFS)、最短作业优先调度(Shortest Job First, SJF)和时间片轮转调度(Round-Robin, RR)。

我们使用C语言编写了一个处理机调度模拟程序,并通过模拟不同进程的到达时间、执行时间和优先级来测试这些调度算法的性能。

实验过程:我们首先设计了一组进程数据,包括到达时间、执行时间和优先级。

然后,我们分别使用FCFS、SJF和RR三种调度算法对这组进程进行调度,并记录每个进程的等待时间和周转时间。

通过这些数据,我们可以评估不同调度算法的性能。

首先,我们使用FCFS算法进行调度。

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

我们发现,FCFS算法的等待时间和周转时间较高。

这是因为当一个长时间的进程到达时,它会占用处理机很长时间,导致其他短进程需要等待较长时间才能执行。

接下来,我们使用SJF算法进行调度。

SJF算法选择执行时间最短的进程来执行,以最小化平均等待时间。

我们发现,SJF算法在减少平均等待时间方面表现出色。

由于短进程的执行时间较短,它们能够更快地完成执行,从而减少其他进程的等待时间。

最后,我们使用RR算法进行调度。

RR算法将处理机时间划分为固定长度的时间片,每个进程在一个时间片内执行,然后切换到下一个进程。

我们发现,RR算法能够公平地分配处理机时间,避免了某个进程长时间占用处理机的问题。

然而,由于每个进程只能在一个时间片内执行,这可能导致一些进程的执行时间被拖延,增加了它们的等待时间和周转时间。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

多道程序cup调度算法实验报告

多道程序cup调度算法实验报告

多道程序cup调度算法实验报告实验报告:多道程序CPU调度算法一、实验目的本实验旨在通过模拟多道程序CPU调度过程,了解不同调度算法对系统性能的影响,加深对CPU调度算法的理解,并掌握常见的调度算法及其特点。

二、实验原理CPU调度是多道程序操作系统中的核心功能,其目的是确定哪个程序在何时占用CPU。

常见的CPU调度算法有先来先服务(FCFS)、最短作业优先(SJF)、最短剩余时间优先(SRTF)、优先级调度等。

三、实验步骤1. 准备实验环境:安装多道程序操作系统模拟软件,如OSLAB、Virtual Machine等。

2. 创建多道程序:编写或导入多个待执行的程序,每个程序具有不同的执行时间和优先级。

3. 配置调度算法:根据实验需求,选择合适的CPU调度算法,并配置相关参数。

4. 启动模拟:运行模拟软件,观察程序的执行过程,记录各程序的执行顺序、等待时间和周转时间等数据。

5. 数据分析:对实验数据进行整理和分析,比较不同调度算法的性能差异。

6. 结论总结:根据实验结果,总结各种调度算法的优缺点,写出实验报告。

四、实验结果及分析1. 实验结果:- 先来先服务(FCFS)调度算法:按照程序的到达顺序进行调度,等待时间和周转时间较长。

- 最短作业优先(SJF)调度算法:优先执行最短的作业,等待时间较短,但需预估作业长度,可能导致不准确性。

- 最短剩余时间优先(SRTF)调度算法:优先执行剩余时间最短的作业,实时性较好,但可能导致饥饿现象。

- 优先级调度算法:根据程序优先级进行调度,可有效处理紧急任务和I/O密集型任务,但可能导致低优先级程序长时间等待。

2. 结果分析:- FCFS算法简单易实现,但不适用于I/O密集型任务。

- SJF算法可减少等待时间,但预估作业长度存在误差。

- SRTF算法实时性较好,但可能导致饥饿现象。

- 优先级调度算法可根据实际需求灵活配置,适用于多种场景,但需合理设置优先级。

五、实验总结通过本次实验,我们了解了多道程序CPU调度的基本原理和常见算法。

操作系统实验之处理机调度实验报告

操作系统实验之处理机调度实验报告
四、开发工具及主要源代码
1、开发工具
Clion for mac 2016,采用 cmake 编译。
2、主要源码
//先来先服务 void FCFS(List *p, int count) {
List temp; int i, j; //按照到达时间排序 for (i = 1; i < count; i++) {
min = 100; temp = p[k].Finish_time; for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time < 0) continue;
if (min > p[j].Service_time) {
max = 0;
temp = p[k].Finish_time; //找响应比最高任务 for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time <= 0) continue;
if (max < (temp - p[j].Arrival_time) / p[j].Service_time) {
if (temp > p[i].Arrival_time) {
temp = p[i].Arrival_time; k = i; } } //按照响应比大小设置优先级,以及相应参数 for (i = 0; i < count; i++) { p[k].order = ++flag; p[k].Start_time = temp; p[k].Wait_time = temp - p[k].Arrival_time; p[k].Finish_time = temp + p[k].Service_time; p[k].Turnover_time = p[k].Finish_time - p[k].Arrival_time; p[k].WeightedTurn_time = p[k].Turnover_time / p[k].Service_time;

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

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

操作系统实验题:设计一若干并发进程的进程调度程序一、实验目的无论是批处理系统、分时系统还是实时系统,用户进程数一般都大于处理机数,这将导致用户进程互相争夺处理机。

这就要求进程调度程序按一定的策略,动态地把处理及分配给处于就绪队列中的某一进程,以使之执行。

进程调度是处理机管理的核心内容。

本实验要求采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念。

并体会了优先数和先来先服务调度算法的具体实施办法。

二、实验要求用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.三、实验内容进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法(将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理)。

每个进程有一个进程控制块( PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪 W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。

就绪进程获得 CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。

重复以上过程,直到所要进程都完成为止。

调度算法实验报告总结(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算法在进程数量较多时,可能会导致调度开销较大。

操作系统处理机调度实验报告

操作系统处理机调度实验报告
}
}
运行后结果如下:
[root@rhel5hbzy ~]# gcc -o chuliji chuliji.c
[root@rhel5hbzy ~]# ./m
CHOOSE THE ALGORITHM:
1 PRIORITY
2 ROUNDROBIN
3 EXIT
1
input name and time
jing 2
if(q->needtime==1)
q->cputime++;
else
q->cputime +=2;
q->needtime -=2;
if(q->needtime<0){
q->needtime = 0;
}
q->count++;
q->process = execute;
}
pcb *get_next(pcb *k,pcb *head){
}
void cpuexe(pcb *q){
pcb *t = q;
int tp = 0;
while(q){
if (q->process!=finish){
q->process = ready;
if(q->needtime==0){
q->process = finish;
}
}
if(tp<q->priority&&q->process!=finish){
aaaa' 1 7 39 ready
bbbb2 0 0 50 finish
ffff2 0 0 50 finish
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
if(Process[a].pri<pritemp)
{
pritemp=Process[a].pri;
z=a;
}
}
Process[z].runbt=temp;
Process[z].runet=Process[z].runbt+Process[z].runt;
temp=Process[z].runet;
for(i=0;i<counter;i++)
{
double max_respond_rate=-1;
for(j=0;j<counter;j++)
{
if(Process[j].run_flag==0)
{
Process[j].respond_rate=(current_time-Process[j].comet)/Process[j].runt;
{
Process[p].runbt=current_time;
}
else
Process[p].runbt=Process[p].comet;
Process[p].runet=Process[p].runbt+Process[p].runt;
Process[p].run_flag=1;
current_counter=current_counter+1;
Process[p].order=current_counter;
current_time=Process[p].runet;
}
return 0;
}
实验
总结
通过这次实验,对CPU的两种调度算法——优先权法和响应比法的调度策略和算法过程有了更深层次的了解,也对两种算法的优缺点有了较为深刻的认识。
教师
评语
}
}
for(j=0;j<counter;j++)
{
if((Process[j].run_flag==0)&&(Process[j].respond_rate>max_respond_rate))
{
p=j;
max_respond_rate=Process[j].respond_rate;
}
}
if(Process[p].comet<=current_time)
Process[z].run_flag=1;
pritemp=100;
Process[z].order=d+1;d++;
}
return 0;
}
2、响应比法
int hrn()
{
int i,j,p;
int current_counter=0;
double current_time=Process[0].comet;
Process[j].run_flag=1;
Process[j].order=d+1;d++;
temp=Process[j].runet;
int priteຫໍສະໝຸດ p=100;int z=0;
for(i=1;i<counter;i++)
{
for(int a=0;a<counter;a++)
{
if(Process[a].run_flag==0)
实验
进度
本次共有2个练习,完成2个。
实验
内容
1、优先权法
int PRI()
{
int j=0,i;
int d=0;
int temp=Process[0].comet;
Process[j].runbt=Process[j].comet;
Process[j].runet=Process[j].comet+Process[j].runt;
成绩
辽宁工程技术大学上机实验报告
课程名称
计算机操作系统
实验题目
CPU的调度程序
院系
软件学院
专业
软件工程
班级
10-04班
姓名
杨慧荣
学号
1020010427
实验日期
2012/12/01
实验
目的
用C++分别采用优先权法和响应比法实现CPU的调度程序。
实验
准备
上课认真听讲,对CPU的两种调度算法——优先权法和响应比法的调度策略有一定的了解和掌握。
相关文档
最新文档