实验四使用动态优先权的进程调度算法的模拟
动态高优先权
动态高优先权实验报告一、实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解.提高自己的动手能力主要是通过自己去思考并自己的编码更进一步及更贴切的去理解弄明白动态优先权算法的模拟加深对进程概念和进程调度过程的工作流程及其原理！二、实验要求用C语言来实现对N个进程采用动态优先权优先算法的进程调度。
三、实验内容每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：1．进程标识数ID2．进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
3．进程已占用的CPU时间CPUTIME。
4．进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
5．进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
6．进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
7．进程状态STATE。
8．队列指针NEXT，用来将PCB排成队列。
四、实验结果五、实验小结其实每次实验，老师都建议大家自己开始写程序，网上的代码可以自己选择性的参考，但绝对不能纯粹性的抄袭，但由于自己的C++基础实在是不怎么好，如果自己编的话会摸不着头脑，不知从哪里开始，就还是从网上下载了一些代码，在同学们的帮助下，理解编着的思路，明白各个模块的调度，也明白了动态高优先权的具体内容。
虽然中间碰见了不少问题，但经过多次调试，还是有了比较满意的结果。
然而这些调试是需要花费时间的，课堂的时间不够，只能课下去完成。
正所谓皇天不负有心人，努力就会有收获，经过这次试验也算是有所提高吧。
动态优先权是指在创建进程时所赋予的优先权,可以随进程的推进或随其等待时间的增加而改变的,以便获得更好的调度性能.例如,我们可以规定,在就绪队列中的进程,随其等待时间的增长,其优先权以速率a 提高.若所有的进程都具有相同的优先权初值,则显然是最先进入就绪队列的进程,将因其动态优先权变得最高而优先获得处理机,此即FCFS算法.优先权的变化规律可描述为：由于等待时间与服务时间之和,就是系统对该作业的响应时间,故该优先权又相当于响应比RP此次实验让我明白了许多，不仅是知识上的，还有认识上的，我明白任何时候都是自己动手丰衣足食，学问是自己的，是无止境的，为了以后我们只能努力的补充自己···附录#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10]; /*定义进程名称*/char state; /*进程状态*/int super; /*优先数*/int ntime; /*需要运行的时间*/int rtime; /*已占用的CPU时间*/struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB; /*pcb表*/void sort() /* 建立对进程进行优先级排列函数*/{ PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者, 插入队首*/{ p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{ first=ready;second=first->link;while(second!=NULL){ if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{ first=first->link;second=second->link;}}if(insert==0) first->link=p;}}void input() /* 建立进程控制块函数*/ { int i,num;system("cls"); /*清屏*/printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;i<num;i++){ printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){ int l=0; PCB* pr=ready;while(pr!=NULL){ l++;pr=pr->link;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{ printf("\n qname \t state \t super \t ndtime \t runtime \n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}void check() /* 建立进程查看函数，检查等待队列的进程是否进入就绪队列*/{ PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){ disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{ printf("\n 进程[%s] 已完成.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ { (p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{ (p->super)--;p->state='w';sort(); /*调用sort函数*/}}void main() /*主函数*/{ int len, h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ ch=getchar();h++;printf("\n The execute number:%d \n",h); p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}。
使用动态优先权的进程调度算法的模拟实验
使用动态优先权的进程调度算法的模拟实验动态优先权调度算法是一种根据进程动态表现调整优先权的进程调度算法。
它不仅考虑了进程的优先级，还将进程的实际执行情况作为调度依据。
下面将介绍一个模拟实验，以更好地理解这种调度算法。
实验背景：假设有五个待执行的进程，它们的ID和初始优先权分别为P1（3）、P2（5）、P3（2）、P4（1）、P5（4）。
这五个进程的优先权在调度过程中会根据实际情况进行动态调整。
实验过程：1.初始化：在实验开始之前，首先需要对进程的初始状态进行初始化。
每个进程有两个属性：优先级和已运行时间。
优先级用于决定进程的调度优先级，已运行时间用于记录进程已经运行了多长时间。
设置一个全局时间片，表示每个时间单元中运行的时间。
2.进程调度：根据进程的优先权，选取最高优先权的进程进行调度。
从P1到P5，进程的优先权逐渐减小。
-选择进程：比如初始时最高优先权的进程为P2-进程执行：进程P2被调度后开始执行，运行一个时间片。
每运行一个时间片，该进程的已运行时间加一，重新计算进程的优先权。
-优先权调整：根据已运行时间的加一，重新计算进程的优先权。
优先权的计算公式可以根据实际需要进行调整，比如可以设为：新的优先权=原优先权+（已运行时间/其中一常量）。
-进程阻塞：如果进程运行的时间超过了一个时间片，则该进程被阻塞，进入就绪队列等待下一次轮转调度，其他进程继续执行。
3.调度进程更新：进程在执行和阻塞的过程中，它们的优先权会发生变化。
在每一轮调度后，需要更新进程的优先权，重新确定每个进程的调度顺序。
4.实验结果：重复进行步骤2和步骤3，直到所有进程都完成执行。
记录每次调度过程中的结果，包括进程的执行顺序、时刻和优先权的变化。
实验分析：通过模拟实验，可以得出以下一些结论：1.动态优先权调度算法能够根据实际情况调整进程的优先权，更好地适应不同进程的需求，增强了调度的灵活性。
2.在实验中，进程运行时间越长，优先权越低。
实验四 使用动态优先权的进程调度算法的模拟
实验四使用动态优先权的进程调度算法的模拟专业班级：软件1302 学号：201316920224 姓名：张长胜评分：1．实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。
2．实验内容(1)用C语言来实现对N个进程采用动态优先权优先算法的进程调度。
(2)每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：●进程标识数ID；●进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高；●进程已占用的CPU时间CPUTIME；●进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0；●进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态；●进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，进程将转换成就绪状态；●进程状态STATE；●队列指针NEXT，用来将PCB排成队列。
(3)优先数改变的原则：●进程在就绪队列中呆一个时间片，优先数增加1；●进程每运行一个时间片，优先数减3。
(4)假设在调度前，系统中有5个进程，它们的初始状态如下：ID 0 1 2 3 4PRIORITY 9 38 30 29 0CPUTIME 0 0 0 0 0ALLTIME 3 3 6 3 4STARTBLOCK 2 -1 -1 -1 -1BLOCKTIME 3 0 0 0 0STATE READY READY READY READY READY(5)为了清楚地观察进程的调度过程，程序应将每个时间片内的进程的情况显示出来，参照的具体格式如下：RUNNING PROG: iREADY_QUEUE:->id1->id2BLOCK_QUEUE:->id3->id4===============================================ID 0 1 2 3 4PRIORITY P0 P1 P2 P3 P4CPUTIME C0 C1 C2 C3 C4ALLTIME A0 A1 A2 A3 A4 STARTBLOCK T0 T1 T2 T3 T4BLOCKTIME B0 B1 B2 B3 B4 STATE S0 S1 S2 S3 S43.程序设计/*define the structure of process*/#include <stdio.h>#define N 10#define P procstruct process{ int id;int py; /*priority*/int ct; /*cputime*/int at; /*alltime*/int sb; /*startblock*/int bt; /*blocktime*/int st; /*state:1 ready;-1 block;0 finish*/};struct process proc[N];main(){ int i,j,n;int max_pt,priority;int timeslice=0;int ready_q[N],block_q[N];char ch;FILE *fp;char *fname="c:\\a.txt";fp=fopen(fname,"w+");for(i=0;i<=N;i++){ ready_q[i]=0; block_q[i]=0;}n=5; /* 定义进程数量为5 *//* 初始化进程数组*/P[1].id=0; P[1].py=9; P[1].ct=0; P[1].at=3; P[1].sb=2; P[1].bt=3;P[2].id=1; P[2].py=38; P[2].ct=0; P[2].at=3; P[2].sb=-1; P[2].bt=0;P[3].id=2; P[3].py=30; P[3].ct=0; P[3].at=6; P[3].sb=-1; P[3].bt=0;P[4].id=3; P[4].py=29; P[4].ct=0; P[4].at=3; P[4].sb=-1; P[4].bt=0;P[5].id=4; P[5].py=0; P[5].ct=0; P[5].at=4; P[5].sb=-1; P[5].bt=0;/* 输出初始化的进程数组内容*/fprintf(fp,"\n\n RUNNING RPOC:%d\n",-1);fprintf(fp," READY_QUEUE :");for(i=1;i<=n;i++)fprintf(fp,"->id%d",i-1);fprintf(fp,"\n");fprintf(fp," BLOCK_QUEUE :\n ");fprintf(fp,"===================================================== ===");fprintf(fp,"\n %-12s","ID");for(i=1;i<=n;i++)fprintf(fp,"%8d",i-1);fprintf(fp,"\n %-12s","PRIORITY");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].py);fprintf(fp,"\n %-12s","CPUTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].ct);fprintf(fp,"\n %-12s","ALLTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].at);fprintf(fp,"\n %-12s","STARTBLOCK");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].sb);fprintf(fp,"\n %-12s","BLOCKTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].bt);fprintf(fp,"\n %-12s","STATE");for(i=1;i<=n;i++){ P[i].st=1;fprintf(fp,"%8s","READY");}for(i=1;i<=n;i++){ P[i].st=1;ready_q[i]=i;}ready_q[0]=n;/* ready_q[0]表示就绪队列中进程个数，block_q[0]表示阻塞队列中进程个数*//* 进行运算*/do{ timeslice++; /* 时间片加1 *//*max_pt记录优先级最高进程的pt,ready_q数组记录就绪队列的顺序priority记录优先级最高进程的ID此程序段使ready_q排序*/for(i=1,max_pt=-1;i<=ready_q[0];i++)if (P[ready_q[i]].py>max_pt){ max_pt=P[ready_q[i]].py;j=i;priority=ready_q[i];}for(i=j;i<ready_q[0];i++)ready_q[i]=ready_q[i+1];ready_q[0]--;/* 按原则操作各进程，实质是按原则改变数组各值*/P[priority].py-=3;if (P[priority].py<0) P[priority].py=0;P[priority].ct++;P[priority].at--;/* 除执行进程外，其他进程的操作*/for(i=1;i<=ready_q[0];i++)P[ready_q[i]].py+=1;/* 对阻塞队列和就绪队列赋值*//*? 进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，进程将转换成就绪状态；*/for(i=1;i<=block_q[0];i++){ P[block_q[i]].bt-=1; /* 阻塞队列中的进程的blocktime－1 */ if (P[block_q[i]].bt==0) /* 如果该进程的blocktime＝0，说明该进程需要进入就绪队列*/{ P[block_q[i]].st=1; /* 将该进程的st状态置1，将其从阻塞队列移入就绪队列*/block_q[0]--;ready_q[0]++;ready_q[ready_q[0]]=i;}}if(P[priority].at==0) /* 对当前执行进程，如果at＝0说明执行完毕*/{ P[priority].st=0;P[priority].py=-1;}else if (P[priority].sb==P[priority].ct) /* 进程的阻塞时间STARTBLOCK，*//* 表示当进程再运行STARTBLOCK个时间片后，*//* 进程将进入阻塞状态；*/ { P[priority].st=-1;block_q[0]++;block_q[block_q[0]]=priority;}else /* 以上两个条件都不符合，直接进入就绪队列*/{ r eady_q[0]++;ready_q[ready_q[0]]=priority;}/* 运行一次后输出运行结果*/fprintf(fp,"\n\n RUNNING RPOC:%d TIMELICE:%d\n",priority-1,timeslice);fprintf(fp," READY_QUEUE :");for(i=1;i<=ready_q[0];i++)fprintf(fp,"->id%d",ready_q[i]-1);fprintf(fp,"\n");fprintf(fp," BLOCK_QUEUE :");for(i=1;i<=block_q[0];i++)fprintf(fp,"->id%d",block_q[i]-1);fprintf(fp,"\n");fprintf(fp,"===================================================== ===");fprintf(fp,"\n %-12s","ID");for(i=1;i<=n;i++)fprintf(fp,"%8d",i-1);fprintf(fp,"\n %-12s","PRIORITY");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].py);fprintf(fp,"\n %-12s","CPUTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].ct);fprintf(fp,"\n %-12s","ALLTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].at);fprintf(fp,"\n %-12s","STARTBLOCK");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].sb);fprintf(fp,"\n %-12s","BLOCKTIME");for(i=1;i<=n;i++)fprintf(fp,"%8d",P[i].bt);fprintf(fp,"\n %-12s","STATE");for(i=1;i<=n;i++){ if(P[i].st==1)fprintf(fp,"%8s","READY");else if (P[i].st==0)fprintf(fp,"%8s","FINISH");elsefprintf(fp,"%8s","BLOCK");}fprintf(fp,"\n");}while((ready_q[0]!=0)||(block_q[0]!=0)); /* 循环结束条件：就绪队列和阻塞队列全为空*/}4.实验结果图1图25.实验结果本次实验的实验目的是通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。
使用动态优先权与时间片轮转的进程调度算法的模拟
计算机与信息工程学院设计性实验报告一、实验目的通过动态优先权调度算法的模拟加深进程概念和进程调度过程的理解。
二、实验仪器或设备虚拟机三、总体设计（设计原理、设计方案及流程等）实验内容(1)在Linux下用C语言编程模拟N个进程采用高优先权优先（要求采用动态优先权）和简单时间片轮转两种进程调度算法。
为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程情况显示出来；(2)进程控制块是进程存在的唯一标志，因此，在模拟算法中每一个进程用一个进程控制块PCB来代表，PCB用一结构体表示。
包括以下字段：●进程标识数id，或者进程的名称name；●进程优先数priority，并规定优先数越大的进程，其优先权越高；●进程需要运行的CPU时间ntime；●进程的运行时间rtime；●进程状态state；●队列指针next，用来将PCB排成队列。
(3)进程在运行过程中其状态将在就绪、执行、阻塞（可选）、完成几种状态之间转换，同时进程可能处于不同的队列中，如就绪队列、阻塞队列（可选）。
在两种调度算法中，考虑分别可以选择什么样的队列及如何实现进程的入队、出队操作；(4)为了便于处理，优先权调度每次也仅让进程执行一个时间片，若在一个时间片内未运行结束，调整进程优先级将其插入就绪队列，进行新一轮调度；(5)优先数改变原则：●进程每运行若一个时间单位，优先数减3；●进程在就绪队列中呆一个时间片，优先数增加1。
（仅供参考，合理即可）(6)优先权调度中，对于遇到优先权一致的情况，可采用FCFS策略解决；(7)由于是模拟进程调度，所以，对被选中的进程并不实际启动运行，而是修改进程控制块的相关信息来模拟进程的一次运行；(8)为了清楚地观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来，参照格式如下:id cputime needtime priority(count) state0 0 2 48 ready1 0 3 47 ready2 0 6 44 ready3 0 5 45 ready4 0 4 46 ready简单时间片轮转调度模拟程序见roundrobin.c，优先权调度大家请参考时间片轮转自行实现，有自己想法的同学可以按照自己的思路独立完成实验，而不用参考roundrobin.c程序。
使用动态优先权的进程调度算法的模拟
使用动态优先权的进程调度算法的模拟动态优先权（Dynamic Priority）调度算法是一种根据进程的行为动态调整其优先级的调度算法。
它是对静态优先权调度算法的一种改进，能够更加灵活和有效地调度进程。
下面我将通过模拟的方式详细介绍动态优先权调度算法。
在动态优先权调度算法中，每个进程都有一个初始优先级，等待时间越长，优先级越高。
当进程开始执行时，系统根据其行为调整它的优先级。
假设有五个进程ReadyQueue={P1, P2, P3, P4, P5}，它们的初始优先级分别为{10, 20, 30, 40, 50}。
每个进程的服务时间分别为{6, 7, 8, 9, 10}。
1.初始化阶段：-进程P1开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-正在运行的时间是指进程执行过程中已经消耗的时间。
2.执行阶段：-进程P1运行6个时间单位后，它已经完成了自己的服务时间。
这时，系统将调度下一个优先级最高的进程P5运行。
-进程P5开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
因为P5执行是第一次运行，所以其正在运行的时间为0。
-进程P5运行10个时间单位后，它也完成了自己的服务时间。
3.更新优先级阶段：-进程P5完成后，进程P2开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-进程P2运行7个时间单位后，它完成了自己的服务时间。
4.重新排序阶段：-进程P3开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-进程P3运行8个时间单位后，它也完成了自己的服务时间。
5.最后的执行阶段：-进程P4开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-进程P4运行9个时间单位后，完成了自己的服务时间。
至此，所有的进程都已经完成了它们的服务时间。
动态优先权调度算法的核心思想是，等待时间越长，优先级越高。
这样做的原因是为了避免饥饿的产生，即一些低优先级的进程因为等待时间太长而无法得到运行。
动态优先权进程调度算法模拟实验报告
动态优先权进程调度算法模拟实验报告动态优先权调度算法是一种动态调度算法，根据进程的优先级来决定下一个要执行的进程。
进程的优先级可以根据其紧迫性、重要性和资源需求等因素来确定。
本实验利用模拟算法来模拟动态优先权调度算法，并通过实例来说明该调度算法的工作原理和优缺点。
一、实验目的通过本实验，我们可以了解动态优先权调度算法的工作原理，掌握如何使用模拟算法来模拟进程的调度过程，进一步了解该调度算法的优缺点。
二、实验环境本实验使用C++编程语言来实现动态优先权调度算法的模拟。
编译器使用Dev-C++。
三、实验步骤1.设计进程控制块（PCB）的数据结构，包括进程优先级、进程标识、进程状态等信息。
2.设计模拟算法来模拟动态优先权调度算法。
具体算法如下：a.初始化就绪队列，将所有的进程按照优先级插入到就绪队列中。
b.选择优先级最高的进程执行，并更新该进程的优先级。
c.执行完毕后更新进程的状态，并将其从就绪队列中删除。
d.如果新的进程到达，将其插入到就绪队列中。
3.实现主函数，模拟进程的创建、调度和执行过程。
4.进行多个实例的测试，观察进程的调度顺序和执行结果。
5.总结实验结果，分析动态优先权调度算法的优缺点。
四、实验结果与分析通过多个实例的测试，我们可以观察到动态优先权调度算法的工作过程和效果。
该算法可以根据进程的优先级来确定下一个要执行的进程，从而可以更好地满足不同进程的需求。
同时，动态优先权调度算法可以确保优先级高的进程能够及时得到执行，提高系统的响应速度。
然而，动态优先权调度算法存在一些缺点。
首先，该算法对进程的优先级要求较高，需要合理设置进程的优先级。
如果优先级设置不合理，可能导致优先级高的进程一直占用CPU资源，而优先级低的进程无法得到执行，造成资源浪费。
其次，该算法没有考虑进程的等待时间和执行时间，容易导致饥饿现象的发生，即一些进程无法得到执行。
五、实验总结通过本实验，我们了解了动态优先权调度算法的工作原理和模拟方法。
使用动态优先权的进程调度算法的模拟实验
使用动态优先权的进程调度算法的模拟实验进程调度算法是操作系统中对进程进行调度的一种策略，动态优先权调度算法是其中一种常用的调度算法。
下面将对动态优先权调度算法进行模拟实验，并对实验结果进行分析。
首先，我们定义进程的属性包括进程编号、到达时间、服务时间、优先权和完成时间等。
动态优先权调度算法的基本思想是根据进程的优先权决定下一个被调度的进程，优先权越高，被调度的机会越大。
实验过程如下：1.创建一个进程队列，用来存放待调度的进程。
2.输入进程的个数，并依次输入每个进程的到达时间、服务时间和优先权。
3.将所有进程按照到达时间进行排序。
4.从排好序的进程队列中选择优先权最高的进程，即优先权最大的进程。
5.通过执行该进程进行模拟，更新进程队列中的进程信息。
6.根据更新后的进程信息，重新选择下一个被调度的进程。
7.重复步骤5和6，直到所有进程执行完毕。
对于每个进程，我们可以记录其等待时间、周转时间和带权周转时间。
等待时间即为该进程在就绪队列中等待的时间，周转时间是指从进程提交到完成的时间，即完成时间减去到达时间，带权周转时间是指每个进程的周转时间除以服务时间，用来评估进程的调度效果。
下面是一个动态优先权调度算法的模拟实验示例：```pythonclass Process:self.id = idself.priority = prioritydef __lt__(self, other):return self.priority < other.prioritydef dynamic_priority_scheduling(processes):queue = []while processes or queue:for process in processes:queue.append(process)processes.remove(process)queue.sort(reverse=True) # 根据进程的优先权进行排序if queue:process = queue.pop(0)for p in queue:if __name__ == '__main__':n = int(input("Enter the number of processes: "))processes = []for i in range(n):priority = int(input("Enter priority for process {}:".format(i+1)))dynamic_priority_scheduling(processes)```以上代码定义了一个Process类来表示进程，并使用动态优先权调度算法对进程进行调度。
操作系统实验——动态优先级进程调度实验报告
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号进程成为当前进程，开始执行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四使用动态优先权的进程调度算法的模拟
一、引言
在操作系统中，进程调度算法的选择对于系统资源的合理分配和性能的优化至关重要。
动态优先权调度算法是一种用于调度多个进程的算法，其根据进程的优先级来动态调整进程的执行顺序。
本实验旨在模拟动态优先权调度算法的工作原理和效果。
二、实验原理
动态优先权调度算法中，每个进程都有一个初始的优先级，并且随着时间的推移，根据其等待时间的增加，调整进程的优先级。
进程的等待时间是指从进程到达就绪队列的时间开始，到进入运行状态之前所经过的时间。
在动态优先权调度算法中，优先级是根据公式计算的：
优先级=初始优先级+等待时间/需要运行时间
该算法的目标是使等待时间较长的进程获得更高的优先级，从而提高系统的响应速度和吞吐量。
三、实验步骤
1.创建一个进程控制块（PCB）的数据结构，其中包含进程的信息，如进程ID、到达时间、需要运行时间、等待时间和优先级等。
2.创建就绪队列和完成队列，用于存放已到达但尚未执行的进程以及已完成执行的进程。
3.从文件读取进程信息，初始化进程控制块，并将进程按照到达时间
的先后顺序插入到就绪队列中。
4.初始化系统时间、当前运行的进程以及系统的空闲时间。
5.依次从就绪队列中选取优先级最高的进程执行，更新进程的等待时
间和优先级。
6.在进程执行完毕后，将其移到完成队列中，并更新系统的空闲时间。
7.当所有进程都已执行完毕时，计算平均等待时间和平均周转时间。
8.输出每个进程的执行情况，包括进程的到达时间、执行时间、等待
时间和周转时间等。
9.结束实验。
四、实验结果分析
通过模拟动态优先权调度算法，我们可以得到每个进程的等待时间和
周转时间，以及整个系统的平均等待时间和平均周转时间。
通过比较不同
进程调度算法的效果，可以评估动态优先权调度算法在提高系统响应速度
和吞吐量方面的优势。
五、实验总结
本实验通过模拟动态优先权调度算法，深入了解了其工作原理和效果。
动态优先权调度算法在提高系统响应速度和吞吐量方面有明显的优势，通
过动态调整进程的优先级，能够使等待时间较长的进程获得更高的执行顺序，从而提高了系统的性能。
[1] Andrew S. Tanenbaum, Modern Operating Systems (4th edition)
[2] Silberschatz A, Galvin P B, Gagne G. Operating System Concepts
[3]张铮,《操作系统教程》
以上是关于实验四：使用动态优先权的进程调度算法的模拟的简要介绍。
在实验中，我们可以通过模拟该调度算法来了解其实际运行情况，并比较不同算法的优劣。
希望本文对您有所帮助！。