操作系统C-进程调度算法实验报告
(完整word版)操作系统-进程调度算法设计与实现实验报告
实验报告课程名称操作系统实验名称进程调度算法设计与实现姓名学号专业班级实验日期成绩指导教师(①实验目的②实验设备和环境③实验内容与步骤④实验结果与分析⑤总结,问题及建议）一、内容：设计一个简单的进程调度算法，模拟OS中的进程调度过程二、要求：①进程数不少于5个；②进程调度算法任选;最好选用动态优先数法，每运行一个时间片优先数减3③用C++（或C）语言编程；④程序运行时显示进程调度过程。
三、步骤:①设计PCB及其数据结构：进程标识数：ID进程优先数：PRIORITY（优先数越大，优先级越高）进程已占用时间片：CPUTIME进程尚需时间片:ALLTIME（一旦运行完毕,ALLTIME为0）进程队列指针：NEXT,用来将PCB排成队列进程状态：STATE(一般为就绪，不用）②设计进程就绪队列及数据结构；③设计进程调度算法,并画出程序流程图;④设计输入数据和输出格式;结构格式：当前正运行的进程:0当前就绪队列:2，1，3,4⑤编程上机，验证结果。
四、分析假设调度前，系统中有5个进程，其初始状态如下：①以时间片为单位调度运行；②每次总是从ALLTIME中不为0，且PRIORITY最大的进程调度运行一个时间片；③上述进程运行后其优先数减3，再修改其CPUTIME和ALLTIME，重复②，③④直到所有进程的ALLTIME均变为0。
五、代码＃include〈iostream〉＃include〈string〉#include<queue〉using namespace std;typedef struct pcb ｛string pName;//进程名int priorityNumber；//优先数float serviceTime；//服务时间float estimatedRunningtime;//估计运行时间char state；//状态bool operator〈(const struct pcb ＆a)const {return priorityNumber > a。
进程调度算法实验报告
进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中的重要组成部分，它决定了进程在CPU上的执行顺序。
合理的进程调度算法能够提高系统的性能和效率，使得多个进程能够公平地共享CPU资源。
本实验旨在通过实际操作和数据分析，探究不同的进程调度算法对系统性能的影响。
二、实验方法1. 实验环境本次实验使用了一台配置较高的计算机作为实验环境，操作系统为Windows 10。
实验中使用了C语言编写的模拟进程调度程序。
2. 实验步骤（1）编写模拟进程调度程序，实现常见的进程调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和优先级调度（Priority）。
（2）设计一组测试用例，包括不同执行时间的进程和不同优先级的进程。
（3）运行模拟进程调度程序，记录每个进程的等待时间、周转时间和响应时间。
（4）根据实验结果分析不同进程调度算法的性能差异。
三、实验结果与分析1. 先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，即先到达的进程先执行。
实验结果显示，该算法对于执行时间较短的进程表现良好，但对于执行时间较长的进程则存在明显的不公平性。
长作业的等待时间较长，导致整体执行效率较低。
2. 最短作业优先（SJF）调度算法最短作业优先调度算法按照进程执行时间的长度进行调度，即执行时间最短的进程先执行。
实验结果显示，该算法能够最大程度地减少平均等待时间和周转时间，提高系统的执行效率。
然而，该算法对于执行时间较长的进程存在饥饿问题，即长作业可能一直等待短作业的执行，导致长作业的等待时间过长。
3. 时间片轮转（RR）调度算法时间片轮转调度算法将CPU的执行时间划分为固定长度的时间片，每个进程按照轮流执行的方式进行调度。
实验结果显示，该算法能够保证每个进程都能够获得一定的执行时间，提高了系统的公平性。
然而，对于执行时间较长的进程而言，由于需要等待其他进程的轮转，其执行效率相对较低。
进程调度实验报告
进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验，加深学生对进程调度原理的理解，掌握各种进程调度算法的特点和应用场景，提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言，通过模拟实现了先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和多级反馈队列（MFQ）四种进程调度算法。
三、实验过程。
1. 先来先服务（FCFS）调度算法。
先来先服务调度算法是一种非抢占式的调度算法，按照进程到达的先后顺序进行调度。
在本次实验中，我们通过模拟多个进程到达并排队等待CPU执行，观察其平均等待时间和平均周转时间。
实验结果表明，先来先服务调度算法适用于作业长度差异较大的情况，但容易产生“饥饿”现象。
2. 最短作业优先（SJF）调度算法。
最短作业优先调度算法是一种非抢占式的调度算法，按照作业执行时间的长短进行调度。
在本次实验中，我们通过模拟多个作业的执行时间，观察其平均等待时间和平均周转时间。
实验结果表明，最短作业优先调度算法能够最大程度地减少平均等待时间，但可能会导致长作业被“饿死”。
3. 时间片轮转（RR）调度算法。
时间片轮转调度算法是一种抢占式的调度算法，每个进程被分配一个时间片，当时间片用完后，该进程被放到队尾等待。
在本次实验中，我们通过模拟多个进程的执行和时间片的调度，观察其平均等待时间和平均周转时间。
实验结果表明，时间片轮转调度算法能够保证每个进程都能得到一定的执行时间，但可能会导致上下文切换频繁。
4. 多级反馈队列（MFQ）调度算法。
多级反馈队列调度算法是一种综合性的调度算法，根据进程的优先级和执行时间进行动态调整。
在本次实验中，我们通过模拟多个进程的执行和不同优先级队列的调度，观察其平均等待时间和平均周转时间。
实验结果表明，多级反馈队列调度算法能够兼顾短作业和长作业，提高了系统的整体性能。
四、实验总结。
通过本次实验，我们深入理解了不同进程调度算法的特点和适用场景。
进程调度操作系统实验报告
进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理，通过实际编程和模拟，观察不同调度算法对系统性能的影响，并掌握进程调度的实现方法。
二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一，它负责决定哪个进程在何时获得 CPU 资源进行执行。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。
先来先服务算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 执行。
这种算法简单直观，但可能导致短作业等待时间过长。
短作业优先算法优先调度执行时间短的进程，能有效减少平均等待时间，但可能导致长作业饥饿。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片进行执行。
如果进程在时间片内未完成，则被放回就绪队列等待下一轮调度。
优先级调度根据进程的优先级来决定调度顺序，优先级高的进程先获得 CPU 资源。
四、实验步骤1、设计进程结构体定义进程的标识号（PID）、到达时间、服务时间、剩余时间、优先级等属性。
2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。
从就绪队列中取出第一个进程进行调度执行，直到其完成。
3、实现短作业优先算法计算每个进程的剩余服务时间。
将进程按照剩余服务时间从小到大排序，放入就绪队列。
从就绪队列中取出剩余服务时间最短的进程进行调度执行。
4、实现时间片轮转算法设定时间片大小。
将进程放入就绪队列，按照先来先服务的原则依次分配时间片执行。
进程在时间片内未完成的，放回就绪队列末尾。
5、实现优先级调度算法为每个进程设置优先级。
将进程按照优先级从高到低排序，放入就绪队列。
从就绪队列中取出优先级最高的进程进行调度执行。
6、计算平均周转时间和平均带权周转时间周转时间＝完成时间到达时间带权周转时间＝周转时间／服务时间平均周转时间＝总周转时间／进程数平均带权周转时间＝总带权周转时间／进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。
操作系统实验报告——调度算法
操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。
2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。
3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。
该算法按照进程到达的先后顺序进行调度。
在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。
3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。
在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。
如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。
在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。
- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。
- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。
5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。
通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。
在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。
《操作系统》上机实验报告—进程调度
《操作系统》上机实验报告实验算法主体内容及#include<stdio.h>#include<dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5 // 共有5 个进程#define P_TIME 50 //作为优先数计算时所用的值enum state{ready,execute,block, finish};//进程的状态，使用枚举struct pcb{char name[4]; // 进程名称int priority; //进程优先级int cputime; //已经占有cpu运行的时间int needtime; //还需要运行的时间int count; //在时间片轮转法中使用的int round; //在时间片轮转法中使用的state process; //进程的状态pcb *next; //指向下一个进程的pcb};pcb *get_process() //通过输入各进程的值来建立pcb队列，并返回其首元素的指针{pcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"<<endl;while(i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name; cin>>q->needtime; q->cputime=O;q->priority=P_TIME-q->needtime;q->round=0; q->count=0;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{ t->next=q; t=q; } i++;}return p;}void display(pcb *p) //显示本轮运行后的进程各状态情况{coutvv" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"优先级"vv" "vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";cout<vp_>priority;coutvv"";switch(p->process) //对枚举类型的输出方法{case ready:cout< <"就绪"<<endl;break;case execute:cout< <"执行"<<endl;break;case block:cout<<"阻塞"<<endl;break;case finish:cout<<"完成"<<endl;break;} p=p->next;}}int process_finish(pcb *q) //判断所有的进程是否运行结束{ -int b=1;while(q&&b){b=b&&q->needtime==O; q=q_>next;} return b;}void cpuexe(pcb *q) //优先级调度算法的一次执行{pcb *t;t=q;int i=0;while(q){if (q->process!=finish){q_>process=ready;if(q->needtime==0) q->process=finish;} if(i<q->priority) if(q->process!=finish){ t=q;i=q->priority;} q=q->next;}t->needtime-=1;t_>priority_=3; if(t->needtime==0)t->process=finish; t->cputime+=1;}void priority_cal() //优先级调度算法{pcb *p;P=get_process();〃取得进程队列int cpu=0;while(!process_finish(p)) //若进程并未全部结束，则还需要执行{cpu++;coutvv"运行次数："vvcpuwendl; cpuexe(p);//一次cpu的执行display(p);//显示本次执行结果}}pcb * get_process_round()Jpcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"《endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime; q->cputime=O;q->round=0;q->count=0;q_>process=ready; q->next=NULL; if(i==0){p=q;t=q;}else{} i++; } return p;} t->next=q; t=q；void cpu_round(pcb *q){-q->count++;q->cputime+=2;q->needtime-=2;if(q->needtime<0)q->needtime=0;q->round++;q->process=execute;}pcb *get_next(pcb *k,pcb *head){ -pcb *t;t=k; do{t=t->next;}while (t && t->process==finish);if(t==NULL){} return t; t=head;while (t->next!=k && t->process==finish) {t=t->next;}void set_state(pcb *p){-while(p){if (p->needtime==O){p->process=finish;}if (p->process==execute){p_>process=ready;} p=p_>next;}}void display_round(pcb *p){ -cout«" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"时间片"vv"" vv"次数"vv""vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";coutvvp->round;coutvv"";coutvvp->count;coutvv"";switch(p->process){case ready:coutv v"就绪"vvendl;break;case execute:coutvv'执行"vvendl;break;case finish:coutvv"完成"vvendl;break;}p=p->next;}}void round_cal(){pcb *p;pcb *r;p=get_process();int cpu=0;r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);coutvv"运行次数"vvcpuvvendl;display_round(p);set_state(p);} }-void display_menu(){ -coutvv"进程调度算法操作:"vvendl;coutvv"1 优先数"vvendl;coutvv"2 时间片轮转"vvendl;coutvv"3 退出"vvendl;}void main(){display_menu();int k;printf("请选择:");scanf("%d",&k);switch(k){case 1:priority_cal();break;case 2:round_cal();break;case 3:break;}} ----------------------------------------------------------------------------------------------------------测试数据:¥间出择1A.时退选r 5642 3込簷运行结果:1优先数S却曰石石<奪--a S 亠 亡疋出尢尤扫 亡、 ^a ^T B a 抄各时 各时 进还进还称进入时|可0 3 0I! IS 运行次数 “称进入时间II态成養成成忧完就完完完&0 94 2R p f c 32 3 4 3 % 扰冋运行次数心 泊称进入吋冋R5 R 5 C4 卜2佳行次数陰态成成成成成状§_f c s ^H Z B6 4 28尸尤32 3 4结果截图与分析2、时间片轮转10 0名称进入时问64 42 运行次数t k 称进入吋间A称进入时间竇鶴躺翻聶s _^->4p 者者者奁廿者_J-^□者者HiH8 数 謝还轎時 0 00 0 0次数0 口2 1 21 2 3 3216 6 42 2 1 20 Q 0D F次数3 E34 4 1 1 e s 02 0 0态成成态成衣成成些兀执完lla兀。
进程的调度实验报告(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("无效的调度算法选择。
进程调度算法实验报告
进程调度算法实验报告Newly compiled on November 23, 2020操作系统实验报告（二）实验题目：进程调度算法实验环境：C++实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较各种算法的性能优劣。
实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。
设计分析：程序流程图：1.2.短进程优先算法3.时间片轮转调度算法实验代码：1.先来先服务算法#include <>#define n 20typedef struct{int id; d;cin>>f[i].runtime;}for(i=0;i<amount;i++) time>f[j+1].atime){diao=f[j].atime;f[j].atime=f[j+1].atime;f[j+1].atime=diao;huan=f[j].id;f[j].id=f[j+1].id;f[j+1].id=huan;}}}for(i=0;i<amount;i++){cout<<"进程:"<<f[i].id<<"从"<<f[i].atime<<"开始"<<","<<"在" <<f[i].atime+f[i].runtime<<"之前结束。
"<<endl;f[i+1].atime=f[i].atime+f[i].runtime;}}2.短进程优先算法#include<>#define n 5#define num 5#define max 65535typedef struct pro{ int PRO_ID;int arrive_time;int sum_time;int flag;}Pro;um_time>s[j+1].sum_time){temp=s[j];s[j]=s[j+1];s[j+1]=temp;lastX=0;}}if(lastX==1) break;}return s[0];}void SPF(int p){if(n>0)int i,j,k,l,tc=0;Pro seq[n];Pro temp_seq[n];printf("短进程优先调度算法SPF\n");printf("请依次输入5个进程的进程号、到达时间和执行时间\n");printf("成员变量用逗号隔开；进程间用回车隔开\n");for(i=0;i<n;i++){scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i].sum_time);}printf("调度顺序是：\n");rrive_time;}tc=bubble(temp);lag=-1;}for(i=0;i<n;i++){for(j=0;j<n;j++){if(seq[j].flag!=1&&seq[j].arrive_time<=tc){seq[j].flag=0;}}for(j=0;j<n;j++){temp_seq[j]=seq[j];if(seq[j].flag!=0){temp_seq[j].sum_time=max;}}l=bubble(temp_seq).PRO_ID;for(j=0;j<n;j++){if(l==seq[j].PRO_ID){k=j;}}tc=tc+bubble(temp_seq).sum_time;seq[k].flag=1;printf("%d",l);}printf("\n");}}void main(){SPF(n);}3.时间片轮转调度算法头文件#include<iostream>#include<>#include<>#include<>#include<>#define MaxNum 100typedef struct pcb 行时间小于0，删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%,带权周转时间=%\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);head->front=p1->next;free(p1);}行时间大于0，向后找位置插入else{printf(" %c\n",p1->state);p2=p1->next;while(p2->next && p2->arrivetime != t){p2=p2->next;}用找位置往后插入，队首不变，不做操作位置往后插入if(p2->arrivetime != t){PCB *p3=p1,*p4;while(p3->next && p3->arrivetime<t){p4=p3;p3=p3->next;}if(p3->arrivetime>t){if(p4!=p1) 行时间小于0，删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%,带权周转时间=%\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);行时间大于0，直接插在队尾else{printf(" %c\n",p1->state);//若原队列只有一个进程，不必往队尾插if(!p1->next)head->front=p1;//若原队列有多个进程else{head->front=p1->next;head->rear->next=p1;head->rear=p1;p1->next=NULL;}}//时刻变化，队列为空时不做时刻变化if(empty(head))return;else{if(head->front->runtime<q)t=t+head->front->runtime;elset=t+q;}}/*******第二种情况结束*********/}}主程序#include<iostream>#include<>#include<>#include<>#include<>#include ""void main(){queue *head;int q;head=init();head=creat(head);printf("\n您输入的时间片轮转进程队列为:\n");print(head);printf("\n请输入时间片轮转调度的时间片为:");scanf("%d",&q);//时间片轮转调度RR(head,q);AverageWT=SumWT/N;AverageWWT=SumWWT/N;printf("平均周转时间=%,平均带权周转时间=%",AverageWT,AverageWWT);}运行结果：先来先服务：短进程：时间片轮：心得体会：这次的实验与上次的实验相比，在很多方面都有更多的难度，所以我们参考了别人很多的程序然后稍作了修改。
操作系统实验——动态优先级进程调度实验报告
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号进程成为当前进程，开始执行。
进程调度算法实验报告
操作系统实验报告(二）实验题目:进程调度算法实验环境:C++实验目得：编程模拟实现几种常见得进程调度算法,通过对几组进程分别使用不同得调度算法，计算进程得平均周转时间与平均带权周转时间,比较各种算法得性能优劣.实验内容:编程实现如下算法：1、先来先服务算法;2、短进程优先算法；３、时间片轮转调度算法。
设计分析:程序流程图：1、先来先服务算法2、短进程优先算法３、时间片轮转调度算法实验代码：1.先来先服务算法#ｉnclｕｄe <iostｒeam、h〉＃definｅｎ20tｙpedef strucｔ{int ｉd；//进程名int atiｍe; //进程到达时间intｒuntime; //进程运行时间}fｃs;vｏiｄmain(）{inｔamouｎt，ｉ,ｊ，diａｏ，huａn;fｃs f[n］；cout<<”请输入进程个数：”＜〈enｄl;cin>＞amouｎt;for（i＝0;i<amｏuｎt；i+＋）{cｏut<＜"请输入进程名,进程到达时间,进程运行时间:”〈＜enｄl；cin>>f［i]、id；ｃin〉＞f［ｉ］、aｔiｍe;ｃｉｎ〉〉f[i］、runｔimｅ；}for(i=0；i〈amounｔ;i＋+）//按进程到达时间得先后排序{ //如果两个进程同时到达,按在屏幕先输入得先运行foｒ(j＝0;j〈amouｎt—i—1;j++)｛if(ｆ［j］、ａtiｍe〉f[j＋1］、ａtime)｛diao=ｆ[j］、atｉmｅ;f［j]、atｉme=ｆ［ｊ+１］、ａtime；f[ｊ+1］、atime=diao;huan=ｆ[j]、ｉd;f［j］、id=f［j+1]、id;f[j+1]、id=huａn；}}}ｆor(i=0;i＜aｍｏuｎt；i++)｛cout〈<”进程："<〈f[i］、id<〈”从"〈＜f[ｉ］、ａtime〈<”开始”〈<＂,”<<"在＂〈〈ｆ[i]、ａtiｍｅ+ｆ[i］、runtime<<”之前结束。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告
课程名称操作系统C
实验学期2012
至2013学年第2学期
学生所在系部
计算机系
年级2010
专业班级网络B10
学生姓名
学号
任课教师
杜杏菁
实验成绩
计算机系制
《操作系统
开课实验室：基础六机房2013年6月3日
实验题目进程调度算法模拟
一、
通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、 调度算法的理解。
进程标识数ID。
进程优先数PRIORITY,并规定优先数越大的进程，其优先权越高。
进程已占用CPU时间CPUTIME
进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK表示当进程再运行STARTBLOC个时间片后，进程将进入阻塞 状态。
进程被阻塞的时间BLOCKTIME表示已阻塞的进程再等待BLOCKTIM个时间片后，将转换成 就绪状态。
进程状态STATE
队列指针NEXT用来将PCB排成队列。
（3）优先数改变的原则：
进程在就绪队列中呆一个时间片，优先数增加1。
进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包
括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
cin> >pro[i]. name»pro[i].atime»pro[i].stime;
}
xia nshi(pro,m);
fcfs(pro,m);
getchar();
}
2.
进程的初始化，先输入进程的数目。创建3个进程，并且分别给它们的进程ID、到达时间、服
务时间赋值。
四、实验结果及分析
1.
#i nclude <stdio.h>
#in clude<iostream> using n amespace std;
|\n”,a[i]. name,a[i].atime,
a[i].ftime,a[i].rtime,a[i].qrtime);printf("Fra bibliotek\n”)；
}
void mai n()
二、
1.硬件设备：PC机一台
2.软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C
\C++\Java等编程语言环境。
三、
（1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权 调度）的调度。
（2） 每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：
{
int i,m;
struct program pro[4];
/*创建进程*/
printf(”******先来先服务算法******\n");
printf(”请输入进程的数目：\n");
scan f("%d",&m);
i=m;
for(i=0;i<m;i++)
{
printf("请输入进程％4的进程名，至U达时间，服务时间\n",i+1);