操作系统处理机调度算法的实现c语言源代码
计算机操作系统课程设计源代码《处理机调度算法的实现源代码》

《处理机调度算法的实现》源代码#include "stdio.h"#include <stdlib.h>#include "time.h"#include <math.h>typedef struct{int id;int reach;float service;int prior;int finish;float turnover;float cum_turnover;}process;process p[20];int sort[20];int wait[20];int n;int alltime=0;char c;void in(){printf("请输入要建立的进程数:\n");scanf("%d",&n);int i;int j;int temp;srand(time(0));for(i=0;i<n;i++){printf("\n进程%d号:\n",i);printf("进程uid:");scanf("%d",&p[i].id);p[i].reach=rand()%10+1;printf("到达时间:%d\n",p[i].reach);p[i].service=rand()%10+1;printf("服务时间:%f\n",p[i].service);if(c=='c'){p[i].prior=rand()%10+1;printf("优先权:%d\n",p[i].prior);}else p[i].prior=0;p[i].finish=0;p[i].turnover=p[i].service;p[i].cum_turnover=p[i].prior;sort[i]=i;alltime=alltime+p[i].service;}for(i=1;i<n;i++){for(j=0;j<n-1;j++){if(p[sort[j]].reach>p[sort[j+1]].reach){temp=sort[j];sort[j]=sort[j+1];sort[j+1]=temp;}}}alltime=alltime+p[sort[0]].reach;}void out(){int i;if(c=='c'){printf("进程uid\t到达时间\t服务时间\t优先权\t完成时间\t周转时间\t带权周转时间\n");for(i=0;i<n;i++)printf("%d\t%d\t\t%f\t%d\t%d\t\t%f\t%f\n",p[i].id,p[i].reach,p[i].service,p[i].prior,p[i].finish,p[i].turnover,p[i].cum_turnover );}else {printf("进程uid\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");for(i=0;i<n;i++)printf("%d\t%d\t\t%f\t%d\t\t%f\t%f\n",p[i].id,p[i].reach,p[i].service,p[i].finish,p[i].turnover,p[i].cum_turnover);}}void timeslice(){int q;int i;int j;int front=-1;int rear=-1;int t=1;int v;printf("\n请输入时间片:\n");scanf("%d",&q);for(i=0;i<alltime;i++){for(j=0;j<n;j++){if((i==p[sort[j]].reach-1)&&(front!=(rear+1)%20)){rear=(rear+1)%20;wait[rear]=sort[j];sort[j]=-1;}}if((front!=rear)||(front>-1)){if(t==1){front=(front+1)%20;v=wait[front];}if(t<=q){p[v].turnover--;if(p[v].turnover==0){t=0;p[v].finish=i+2;p[v].turnover=p[v].finish-p[v].reach;p[v].cum_turnover=p[v].turnover/p[v].service;if(front==rear){front=-1;rear=-1;}}if((t==q)&&(p[v].turnover!=0)){rear=(rear+1)%20;wait[rear]=v;t=0;}t++;}}}}//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//短作业优先void sjf(){int top=-1;//作用于wait[]int i;int j;int k;int l;int temp;int v=-1;//处理机正在进行处理的进程号for(i=0;i<=alltime;i++){for(j=0;j<n;j++){//将到达的进程放进等待栈if((i==p[sort[j]].reach-1)&&(top<19)){top++;wait[top]=sort[j];for(k=1;k<=top;k++){//将等待栈按进程服务时间从大到小进行排列for(l=0;l<top;l++){if(p[wait[l]].service<p[wait[l+1]].service){temp=wait[l];wait[l]=wait[l+1];wait[l+1]=temp;}//相同服务时间的先到达的先处理if(p[wait[l]].service==p[wait[l+1]].service){if(p[wait[l]].reach < p[wait[l+1]].reach){temp=wait[l];wait[l]=wait[l+1];wait[l+1]=temp;}}}}}}if((v==-1)&&(top>=0)){//出栈一个进程v=wait[top];top--;}if(v>-1){//处理机运行,服务时间自减、这里的"turnover"指的是服务时间p[v].turnover--;if(p[v].turnover==0){p[v].finish=i+2;p[v].turnover=p[v].finish-p[v].reach;p[v].cum_turnover=p[v].turnover/p[v].service;v=-1;}}}} //动态优先级void fpf(){int top=-1;//作用于wait[]int i,j,k,l,temp;int v=-1;//处理机正在进去处理的进程号for(i=0;i<=alltime;i++){//优先权加1if((i>0)&&(top>-1)){for(j=0;j<=top;j++){p[wait[j]].cum_turnover++;}}for(j=0;j<n;j++){//将到达的进程放进等待栈if((i==p[sort[j]].reach-1)&&(top<19)){top++;wait[top]=sort[j];for(k=1;k<=top;k++){//将等待栈按进程优先权从小到大进行排列for(l=0;l<top;l++){if(p[wait[l]].cum_turnover>p[wait[l+1]].cum_turnover){temp=wait[l];wait[l]=wait[l+1];wait[l+1]=temp;}//相同优先权的先到达的先处理if(p[wait[l]].cum_turnover==p[wait[l+1]].cum_turnover){if(p[wait[l]].reach < p[wait[l+1]].reach){temp=wait[l];wait[l]=wait[l+1];wait[l+1]=temp;}}}}}}if((v==-1)&&(top>=0)){//出栈一个进程v=wait[top];top--;}if(v>-1){//处理机运行,服务时间自检,这里的"turnver"指的是服务时间p[v].turnover--;if(p[v].turnover==0){p[v].finish=i+2;p[v].turnover=p[v].finish-p[v].reach;p[v].cum_turnover=p[v].turnover/p[v].service;v=-1;}}}}//主函数int main(){while(1){printf("\n\n请选择调度算法\na:时间片轮法\nb:短作业优先\nc:动态优先级\n");scanf("%s",&c);in();switch(c){case 'a':timeslice();break;case 'b':sjf();break;case 'c':fpf();break;}out();}return 0;}。
操作系统进程调度C语言代码

操作系统进程调度C语言代码操作系统是计算机系统中的重要组成部分,用于管理和控制计算机资源的分配和使用。
在操作系统中,进程调度是指将系统资源(如 CPU、内存、磁盘、网络等)分配给运行中的进程的过程。
进程调度是操作系统实现多任务、多用户和分时系统的关键。
进程调度的算法有多种。
最常见的是时间片轮转算法、优先级调度算法、最短进程优先算法和先到先服务算法等。
下面我们将介绍一下时间片轮转算法的 C 语言代码实现。
1. 时间片轮转算法时间片轮转算法是一种基于时间片的调度算法,它给每个进程分配一个时间片,当时间片用完后,系统将进程暂停,并将 CPU 分配给下一个进程。
时间片轮转算法可以让所有进程公平地使用 CPU 时间,并且可以避免进程饥饿的情况发生。
2. C 语言代码实现在 C 语言中,可以用结构体来表示一个进程,包括进程 ID、进程状态、优先级、到达时间和需要运行的时间片等属性。
下面是一个简单的进程结构体的定义:```struct Process processes[5];在实现时间片轮转算法之前,需要先实现一个进程调度函数,它的作用是找到就绪进程中优先级最高的进程,并返回它的位置。
下面是一个简单的进程调度函数:```int find_highest_priority_process(struct Process *processes, int n) {int highest_priority = -1;int highest_priority_index = -1;for (int i = 0; i < n; i++) {if (processes[i].state != 2 && processes[i].priority >highest_priority) {highest_priority = processes[i].priority;highest_priority_index = i;}}return highest_priority_index;}```在实现时间片轮转算法之前,需要先定义一些全局变量,包括就绪队列、当前时间、时间片大小和进程数量等。
操作系统进程调度算法(c语言实现)

操作系统进程调度算法(c语⾔实现)进程调度算法⼀、先来先服务(FCFS)基本思想:先到达的进程先进⼊就绪队列,先进⾏调度的原则。
⾮抢占⽅式。
⼆、短作业优先(SJF)基本思想:根据进程中的执⾏时间,选取执⾏时间最短的作业优先调度;可有抢占或⾮抢占⽅式。
三、优先权⾼者优先(HPF)基本思想:系统根据作业的优先权进⾏作业调度,每次选取优先权⾼的作业优先调度。
作业的优先权通常⽤⼀个整数表⽰,也叫做优先数。
可有抢占或⾮抢占⽅式。
四、时间⽚轮转(RR)基本思想:系统将所有的就绪进程按先来先服务的原则,排成⼀个队列,每次调度时,把CPU分配给队⾸进程,并令其执⾏⼀个时间⽚。
时间⽚结束之后,将该进程加到就绪队列队尾;然后再把处理机分配给就绪队列中新的⾸进程。
各程序的实现算法(1)FCFS先来先服务算法思想:①⾸先将输⼊的进程放⼊⼀个进程数组中,然后根据进程的到达时间进⾏排序(冒泡排序)。
将最先到达的进程放⼊进程就绪队列中。
②当队列不空时,从队头取出⼀个进程来执⾏,直⾄此进程执⾏完,并将在此进程执⾏期间到达的进程依次加⼊进程就绪队列。
③如果队列为空,但进程数组中仍存在未到达的进程,这时将要到达进程加⼊进程就绪队列。
void FCFS(program pro[],int num){printf("进程到达时间服务时间开始时间完成时间周转时间带权周转时间\n");sortWithEnterTime(pro,num);//按照到达顺序排序programQueue* queue =(programQueue*)malloc(sizeof(programQueue));Queueinit(queue);//初始化进程就绪队列EnterQueue(queue,&pro[0]);//将第⼀个进程放⼊队列int time = pro[0].enter_time;int pronum=1;//记录当前已进⼊的进程float sum_T_time =0,sum_QT_time =0;while(queue->size>0){//当队列不为空program* curpro =poll(queue);//从进程队列中取出进程if(time<curpro->enter_time)//如果此进程的进⼊时间⼤于此时的时间,需要将时间转换到此进程的到达时间time = curpro->enter_time;int done_time = time+curpro->running_time;//记录完成时间int T_time = done_time - curpro->enter_time;//记录周转时间sum_T_time += T_time;float QT_time = T_time /(curpro->running_time+0.0);//记录带权周转sum_QT_time += QT_time;for(int tt = time;tt<=done_time&&pronum<num;tt++){//模拟进程的执⾏过程if(tt>=pro[pronum].enter_time){//程序执⾏时有程序到达则进⼊程序队列EnterQueue(queue,&pro[pronum]);pronum++;}}printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time,T_time,QT_time);//输出结果time += curpro->running_time;if(queue->size==0&&pronum<num){//防⽌出现前⼀个进程执⾏完到下⼀个进程到达之间⽆进程进⼊EnterQueue(queue,&pro[pronum]);pronum++;}}printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));}(2)短作业优先(SJF)算法思想:①⾸先也是按进程的到达时间进⾏排序。
操作系统实验处理机调度C语言实现

#include<stdio.h>#include<stdlib.h>#include <conio.h>#include<math.h>#define N 20#define MAX 100typedef struct PCB //pcb进程控制块定义{int num[N]; //进程序号char name[10]; //进程名char state; //进程状态int tijiaotime; //进程到达时间int runtime; //进程开始时间int finishtime; //进程结束时间int needtime; //服务时间int pro;//进程优先级struct PCB *next; //链接指针指向下个作业的}pcb;struct PCB *head_input;struct PCB *head_run;struct PCB *head_run_pre;unsigned long current; //记录系统当前时间的变量int time=10000,n; //计时器pcb *head=NULL,*p,*q;void getInfo() //创建进程{int num;printf("\n请输入要建立的进程个数:");scanf("%d",&n);for(num=0;num<n;num++){p=(pcb *)malloc(sizeof(pcb));if(head==NULL) {head=p;q=p;}printf("依次输入:\n进程号进程名到达时间服务时间 \n");scanf("%s\t%s\t%d\t%d",&p->num,&p->name,&p->tijiaotime,&p->needtime);if(p->tijiaotime < time) time=p->tijiaotime;q->next=p;p->runtime=0;p->finishtime=0;p->next=NULL;p->state='W';q=p;}}// *********************1.先来先服务调度算法******************************* void run_fcfo(pcb *p1)//定义先来先到服务的算法{time = p1->tijiaotime > time? p1->tijiaotime:time;p1->runtime=time;printf("\n现在时间是%d,开始运行进程%s\n",time,p1->name);time+=p1->needtime;p1->state='F';p1->finishtime=time;printf("进程名开始时间所需时间结束时间\n");printf("%s %d %d %d ",p1->name,p1->runtime,p1->needtime,p1->finishtime); }void fcfo()//定义运行进程函数{int i,j,t;for(j=0;j<n;j++){p=head;t=10000;for(i=0;i<n;i++) //找到当前未完成的进程{if(p->tijiaotime<t && p->state=='W'){t=p->tijiaotime;q=p; //标记当前未完成的进程}p=p->next;}run_fcfo(q);}}// ************************2.优先级调度服务算法************************************int readydata(){ //建立就绪队列if(head_input->next==NULL){return 0;}struct PCB *p1=head_input->next,*pmax,*p2;int maxpro=0xffff;pmax=p1;p2=head_input;while(p1!=NULL){if(p1->pro<maxpro){maxpro=p1->pro;head_run_pre=p2;pmax=p1;}p2=p1;p1=p1->next;}head_run=pmax;head_run_pre->next=head_run->next;return 1;}void runprocess() //运行进程函数{head_run->runtime-=10;head_run->pro++;struct PCB *p1,*p2;printf("时间片的大小 %d",current);current+=10;printf(" %s 开始\n",head_run->name);printf("时间片的大小 %d",current);printf(" %s 结束\n",head_run->name);if(head_run->runtime<=0){//判断进程是否运行结束}else{p1=head_input;p2=head_input->next;p1->next=head_run;head_run->next=p2;}}int readyprocess(){while(1){if(readydata()==0)return 0;else runprocess();}}void Init(){head_input=new PCB;head_input->next=NULL;current=0;int numpro;printf("请重新输入要建立的进程个数:");scanf("%d",&numpro);printf("请依次输入进程名运行时间优先级\n");for(int i=0;i<numpro;i++){struct PCB *p1=new PCB;scanf("%s",p1->name);scanf("%d",&p1->runtime);scanf("%d",&p1->pro);p1->state='C';p1->next=NULL;struct PCB *p2=head_input->next;head_input->next=p1;p1->next=p2;}}// ************************3.时间片轮转调度服务算法************************************ void shijianpian(){ int b,i,X,t,k;int a[MAX];//存放进程的剩余时间int cnt[MAX];//存放进程调度次数printf("请输入进程数:");scanf("%d",&X);printf("\n请输入时间片t大小:");scanf("%d",&t);printf("\n请依次输入各个进程的服务时间");for(i=0;i<X;i++){scanf("%d",&a[i]);cnt[i]=0;}printf("被调度进程\t进程调度次数 \t本次运行时间结果\t剩余时间\n");k=1;while(k){for(i=0;i<X;i++){if(a[i]!=0)if(a[i]>=t){a[i]-=t;b+=t;cnt[i]=cnt[i]+1;printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);}else{b=b+a[i];cnt[i]=cnt[i]+1;a[i]=0;printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);}else continue;}for(i=0;i<X;i++)if(a[i]!=0){ k=1;break;}else continue;if(i>=X)k=0;}}void main(){printf(" *******************************");printf("\n 1. 按先来先到服务调度的算法模拟\n"); printf(" *******************************");getInfo();fcfo();printf("\n *******************************");printf("\n 2. 按优先级调度的算法模拟\n");printf("\n *******************************\n"); Init();readyprocess();printf("\n *******************************");printf("\n 3. 按时间片轮转调度的算法模拟\n");printf(" *******************************\n"); shijianpian();printf(" \n");}。
操作系统进程调度算法代码

操作系统进程调度算法代码操作系统进程调度算法代码介绍在计算机系统中,进程是指正在执行的程序实例。
当系统中有多个进程需要运行时,操作系统需要对它们进行调度,以保证资源的合理利用和系统的高效运行。
进程调度算法是操作系统中非常重要的一部分,它决定了进程之间的优先级、时间片大小等关键参数,直接影响到系统的性能和用户体验。
本文将介绍常见的几种进程调度算法,并给出相应的代码实现。
1. 先来先服务(FCFS)先来先服务(First-Come, First-Served)是最简单、最直接的进程调度算法。
按照提交时间顺序为进程分配CPU时间片,即先到达CPU请求者先获得CPU使用权。
代码实现:```void FCFS(ProcessList list) {int time = 0; // 当前时间for (int i = 0; i < list.size(); i++) {Process p = list.get(i);p.waitTime = time - p.arrivalTime; // 计算等待时间time += p.burstTime;p.turnaroundTime = time - p.arrivalTime; // 计算周转时间}}```2. 短作业优先(SJF)短作业优先(Shortest Job First)是一种基于作业长度的非抢占式进程调度算法。
按照作业长度为进程分配CPU时间片,即短作业先执行。
代码实现:```void SJF(ProcessList list) {int time = 0; // 当前时间while (!list.isEmpty()) {Process p = list.getShortestJob(); // 获取最短作业p.waitTime = time - p.arrivalTime; // 计算等待时间time += p.burstTime;p.turnaroundTime = time - p.arrivalTime; // 计算周转时间 list.remove(p); // 从列表中删除已经完成的进程}}```3. 高响应比优先(HRRN)高响应比优先(Highest Response Ratio Next)是一种基于响应比的非抢占式进程调度算法。
调度算法C语言实现

调度算法C语言实现调度算法是操作系统中的重要内容之一,它决定了进程在系统中的运行方式和顺序。
本文将介绍两种常见的调度算法,先来先服务(FCFS)和最短作业优先(SJF),并用C语言实现它们。
一、先来先服务(FCFS)调度算法先来先服务(FCFS)调度算法是最简单的调度算法之一、它按照进程到达的先后顺序进行调度,即谁先到达就先执行。
实现这个算法的关键是记录进程到达的顺序和每个进程的执行时间。
下面是一个用C语言实现先来先服务调度算法的示例程序:```c#include <stdio.h>//进程控制块结构体typedef structint pid; // 进程IDint arrivalTime; // 到达时间int burstTime; // 执行时间} Process;int maiint n; // 进程数量printf("请输入进程数量:");scanf("%d", &n);//输入每个进程的到达时间和执行时间Process process[n];for (int i = 0; i < n; i++)printf("请输入进程 %d 的到达时间和执行时间:", i);scanf("%d%d", &process[i].arrivalTime,&process[i].burstTime);process[i].pid = i;}//根据到达时间排序进程for (int i = 0; i < n - 1; i++)for (int j = i + 1; j < n; j++)if (process[i].arrivalTime > process[j].arrivalTime) Process temp = process[i];process[i] = process[j];process[j] = temp;}}}//计算平均等待时间和平均周转时间float totalWaitingTime = 0; // 总等待时间float totalTurnaroundTime = 0; // 总周转时间int currentTime = 0; // 当前时间for (int i = 0; i < n; i++)if (currentTime < process[i].arrivalTime)currentTime = process[i].arrivalTime;}totalWaitingTime += currentTime - process[i].arrivalTime;totalTurnaroundTime += (currentTime + process[i].burstTime) - process[i].arrivalTime;currentTime += process[i].burstTime;}//输出结果float avgWaitingTime = totalWaitingTime / n;float avgTurnaroundTime = totalTurnaroundTime / n;printf("平均等待时间:%f\n", avgWaitingTime);printf("平均周转时间:%f\n", avgTurnaroundTime);return 0;```以上程序实现了先来先服务(FCFS)调度算法,首先根据进程的到达时间排序,然后依次执行每个进程,并计算总等待时间和总周转时间。
操作系统进程调度C语言代码

操作系统进程调度C语言代码#include <stdio.h>#define MAX 20//进程控制块typedef struct PCBchar name[10]; // 进程名int AT; // 到达时间int BT; // 服务时间int Pri; // 优先数int FT; // 完成时间int WT; //等待时间int RT; // 响应时间int position; // 第几号进程int flag; // 用来判断进程是否执行过}PCB;//进程调度void schedule(PCB a[], int n, int alg)int i, j, k, flag, temp;int count = 0;int pri_max = 0;float ATAT = 0.0;float AWT = 0.0;float ART = 0.0;PCBt;//各种算法的调度if (alg == 1)printf("采用先来先服务调度:\n"); //根据到达时间执行for (i = 0; i < n; i++)for (j = i + 1; j < n; j++)if (a[i].AT > a[j].AT)t=a[i];a[i]=a[j];a[j]=t;}//按到达时间依次执行for (i = 0; count != n; i++)for (j = 0; j < n; j++)//查找第一个到达时间小于等于当前时间的进程if (a[j].AT <= i && a[j].flag == 0)//记录运行时间a[j].BT--;//如果运行完成,记录完成时间、等待时间、响应时间if (a[j].BT == 0)a[j].FT=i+1;a[j].WT = a[j].FT - a[j].AT - a[j].Pri;a[j].RT=a[j].WT;a[j].flag = 1;count++;}elsebreak;}}}else if (alg == 2)printf("采用最短服务时间优先(非抢占)调度:\n");for (i = 0; count != n; i++)//找出服务时间最短的进程,并将其放置到最前面for (j = 0; j < n; j++)。
计算机操作系统课程设计源代码《通用处理机调度演示程序源代码》

《通用处理机调度演示程序源代码》//短作业优先算法#define MaxNum 100#include <stdio.h>#include <stdlib.h>#include <string.h>struct Process_struct{int Number; //进程编号char Name[MaxNum]; //进程名称int ArrivalTime; //到达时间int ServiceTime; //开始运行时间int FinishTime; //运行结束时间int WholeTime; //运行时间int run_flag; //调度标志int order; //运行次序double WeightWholeTime; //周转时间double AverageWT_FCFS,AverageWT_SJF; //平均周转时间double AverageWWT_FCFS,AverageWWT_SJF; //平均带权周转时间}Process[MaxNum];int N; //实际进程个数int SJF(); //短作业优先int SJF(){ //短作业优先算法int temp_time=0; //当期那时间int i=0,j;int number_schedul,temp_counter; //进程编号,当前已执行进程个数float run_time;run_time=Process[i].WholeTime;j=1;while((j<N)&&(Process[i].ArrivalTime==Process[j].ArrivalTime)) //判断是否有两个进程同时到达{if(Process[j].WholeTime<Process[i].WholeTime){run_time=Process[i].WholeTime;i=j;}j++;}//查找下一个被调度的进程//对找到的下一个被调度的进程求相应的参数number_schedul=i;Process[number_schedul].ServiceTime=Process[number_schedul].ArrivalTim e;Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime +Process[number_schedul].WholeTime;Process[number_schedul].run_flag=1;temp_time=Process[number_schedul].FinishTime;Process[number_schedul].order=1;temp_counter=1;while(temp_counter<N){for(j=0;j<N;j++){if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag)){run_time=Process[j].WholeTime;number_schedul=j;break;}}for(j=0;j<N;j++){if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag))if(Process[j].WholeTime<run_time){run_time=Process[j].WholeTime;number_schedul=j;}}//查找下一个被调度的进程//对找到的下一个被调度的进程求相应的参数Process[number_schedul].ServiceTime=temp_time;Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime +Process[number_schedul].WholeTime;Process[number_schedul].run_flag=1;temp_time=Process[number_schedul].FinishTime;temp_counter++;Process[number_schedul].order=temp_counter;}return 0;}int Pinput(); //进程参数输入int Poutput(); //调度结果输出int Pinput() //进程参数输入{int i;printf("请输入进程个数:\n");scanf("%d",&N);for(i=0;i<N;i++){printf("----------------------------------------\n");printf("请输入一个进程:\n",i+1);printf("请输入进程名称:\n");scanf("%s",Process[i].Name);printf("请输入到达时间:\n");scanf("%d",&Process[i].ArrivalTime);printf("请输入服务时间:\n");scanf("%d",&Process[i].WholeTime);Process[i].ServiceTime=0;Process[i].FinishTime=0;Process[i].WeightWholeTime=0;Process[i].order=0;Process[i].run_flag=0;}return 0;}int Poutput() //调度结果输出{int i;float turn_round_time=0,f1,w=0;printf(" 进程名称到达时间运行时间开始运行时间结束时间执行顺序周转时间带权周转时间\n");for(i=0;i<N;i++){Process[i].WeightWholeTime=Process[i].FinishTime-Process[i].ArrivalTime;f1=Process[i].WeightWholeTime/Process[i].WholeTime;turn_round_time+=Process[i].WeightWholeTime;w+=f1;printf("时刻%d :",Process[i].ServiceTime,Process[i].Name);printf(" %s %d %d %d %d %d %f %f\n",Process[i].Name,Process[i].ArrivalTime,Process[i].WholeTime,Process[i].Ser viceTime,Process[i].FinishTime,Process[i].order,Process[i].WeightWholeTime,f1);}printf("average_turn_round_timer=%f\n",turn_round_time/N);printf("weight_average_turn_round_timer=%f\n",w/N);return 0;}//时间片轮转算法typedef struct node{char name[20];int round;int cputime;int arrivetime;int needtime;char state;int count;struct node *next;}PCB;PCB *ready=NULL,*run1=NULL,*finish=NULL; int num,i;void GetFirst();void Output();void InsertTime(PCB *in);void InsertFinish(PCB *in);void TimeCreate();void RoundRun();void GetFirst() /*取得第一个就绪队列节点*/ {run1 = ready;if(ready!=NULL){run1 ->state = 'R';ready = ready ->next;run1 ->next = NULL;}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\tcpu时间\t需要时间\t进程状态\t计数器\n");while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\t%d\n",p->name,p->cputime,p->needtime,p->stat e,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\t%d\n",p->name,p->cputime,p->needtime,p->stat e,p->count);p = p->next;}p = run1;while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\t%d\n",p->name,p->cputime,p->needtime,p->stat e,p->count);p = p->next;}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/{PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字到达时间进程所需时间时间片大小:\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s %d %d %d",tmp->name,&(tmp->arrivetime),&(tmp->needtime),&(tmp ->round));getchar();tmp ->cputime = 0;tmp ->state ='W';// tmp->prio=0;tmp ->count = 0;InsertTime(tmp);}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run1 != NULL){Output();while(flag){run1->cputime++ ;run1->needtime--;run1->count++;if(run1->needtime == 0){run1 ->state = 'F';InsertFinish(run1);flag = 0;}else if(run1->count == run1->round){run1->state = 'W';run1->count=0;InsertTime(run1);flag = 0;}}flag = 1;GetFirst();}}//先来先服务算法typedef struct PCB //定义进程控制块{char ID[3]; //进程号char name[10]; //进程名char state; //运行状态int arrivetime; //到达时间int starttime; //进程开始时间int finishtime; //进程结束时间int servicetime; //服务时间float turnaroundtime;//周转时间float weightedturnaroundtime;//带权周转时间struct PCB *next; //指向下个进程}pcb;int time; //计时器int n; //进程个数pcb *head1=NULL,*p,*q; //进程链表指针void run_fcfs(pcb *p1) //运行未完成的进程{time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间是%d,开始运行作业%s\n",time,p1->name);time+=p1->servicetime;p1->state='T';p1->finishtime=time;p1->turnaroundtime=p1->finishtime-p1->arrivetime;p1->weightedturnaroundtime=p1->turnaroundtime/p1->servicetime; printf("ID 到达时间开始时间服务时间完成时间周转时间带权周转时间\n"); printf("%s%6d%10d%10d%8d%10.1f%10.2f\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p1->finishtime, p1->turnaroundtime,p1->weightedturnaroundtime);}void fcfs() //找到当前未完成的进程{int i,j;p=head1;for(i=0;i<n;i++){if(p->state=='F'){q=p; //标记当前未完成的进程run_fcfs(q);}p=p->next;}}void getInfo() //获得进程信息并创建进程{int num;printf("\n作业个数:");scanf("%d",&n);for(num=0;num<n;num++){p=(pcb *)malloc(sizeof(pcb));printf("依次输入:\nID 进程名到达时间服务时间\n");scanf("%s\t%s\t%d\t%d",&p->ID,&p->name,&p->arrivetime,&p->servicetime); if(head1==NULL) {head1=p;q=p;time=p->arrivetime;}if(p->arrivetime < time) time=p->arrivetime;q->next=p;p->starttime=0;p->finishtime=0;p->turnaroundtime=0;p->weightedturnaroundtime=0;p->next=NULL;p->state='F';q=p;}}//静态优先权优先算法int SequenceNumber=1; //进程编号int ProcessAmount; //进程数量int StartCount=0; //调入内存进程计数struct PCB1{ //进程控制块int No; //进程号char name[16]; //进程名int enterMemoryTime;//进入内存时间int serviceTime; //服务时间int priority; //优先级struct PCB1 *next;};struct PCB1 *head,*thisP,*newP; //动态接收进程及详细struct PCB1 *readyHead; //动态存储就绪队列//函数声明int getch();int timeOfData(FILE *);void ListAllPCB();void Menu();void printPCB(struct PCB1 *,int,int,int,double);void printPCBP(struct PCB1 *);void printField();void printFieldP();void release(struct PCB1 *);void releaseR(struct PCB1 *);void setNewPCB(char *,int,int,int);struct PCB1 * runTheProcess();void newPCB(){ //建立PCBnewP=(struct PCB1 *)malloc(sizeof(struct PCB1));if(head==NULL){ //判断头节点是否为空head=newP; //为空,头节点指向新开辟的内存}else{thisP=head;while(thisP->next!=NULL){thisP=thisP->next;}thisP->next=newP; //遍历单链表,找到最后一个元素}thisP=newP;thisP->No=SequenceNumber;SequenceNumber++;printf("进程号%d\n",thisP->No);printf("输入进程名:");scanf("%s",thisP->name);printf("输入优先级:");scanf("%d",&thisP->priority);printf("输入进入内存时间:");scanf("%d",&thisP->enterMemoryTime);printf("输入服务时间:");scanf("%d",&thisP->serviceTime);thisP->next=NULL;}void buildProcess(){ //创建进程int i=0;printf("输入进程数量:");scanf("%d",&ProcessAmount);while(i<ProcessAmount){newPCB();i++;}}void readyList(struct PCB1 *pcb){ //单链表的形式创建就绪队列newP=(struct PCB1 *)malloc(sizeof(struct PCB1));if(readyHead==NULL){readyHead=newP;}else{thisP=readyHead;while(thisP->next!=NULL){thisP=thisP->next;}thisP->next=newP;}thisP=newP;strcpy(thisP->name,pcb->name);thisP->No=pcb->No;thisP->priority=pcb->priority;thisP->enterMemoryTime=pcb->enterMemoryTime;thisP->serviceTime=pcb->serviceTime;thisP->next=NULL;}struct PCB1 * callMemory(){ //调入内存,返回调入内存的链表节点int at; //到达时间struct PCB1 *markP;if(head==NULL){printf("程序没有找到。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
处理机调度算法的实现
处理机调度算法的实现
1.设定系统中有五个进程,每一个进程用一个进程控制块表示。
2.输入每个进程的“优先数”和“要求运行时间”,
3.为了调度方便,将五个进程按给定的优先数从大到小连成就绪队列。
用一单元指出队列首进程,用指针指出队列的连接情况。
4.处理机调度总是选队首进程运行。
采用动态优先数算法,进程每运行一次优先数就减“1”,同时将运行时间减“1”。
5.若要求运行时间为零,则将其状态置为“结束”,且退出队列。
6.运行所设计程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
#include <stdio.h>
#include <stdlib.h>
struct PCB {
char name[10];
int priority,time;
struct PCB *next;
}*k;
struct LinkQueue {
PCB * front;
PCB * rear;
};
//队列初始化
LinkQueue init(){
LinkQueue Q;
PCB * p;
p=(PCB *)malloc(sizeof(PCB));
if(p) {
Q.front=Q.rear=p;
Q.front->next=NULL;
return Q;
}else{
printf("队列初始化失败,程序运行终止! \n");
exit(0);
}
}
//插入新进程,使优先数从大到小排列
LinkQueue sort(LinkQueue Q,PCB *p) {
PCB * temp1;
PCB * temp2;
if(Q.rear==Q.front) {
Q.front->next=p;
Q.rear=p;
} else {
temp1=Q.front;
temp2=temp1->next;
while(temp2->priority>=p->priority && temp2->next!=NULL) {
temp1=temp2;
temp2=temp1->next;
}
if(temp2->next==NULL && temp2->priority>=p->priority) {
temp2->next=p;
Q.rear=p;
} else {
p->next=temp1->next;
temp1->next=p;
}
}
return Q;
}
LinkQueue input(LinkQueue Q) /* 建立进程控制块函数*/
{
int i;
for(i=1;i<=5;i++)
{
printf("\n 进程号No.%d:\n",i);
k=(PCB *)malloc(sizeof(PCB));
printf("\n 输入进程名:");
scanf("%s",k->name);
printf("\n 输入进程优先数:");
scanf("%d",&k->priority);
printf("\n 输入进程运行时间:");
scanf("%d",&k->time);
printf("\n");
k->next=NULL;
Q=sort(Q,k); /* 调用sort函数*/
}
return Q;
}
LinkQueue running(LinkQueue Q) /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {
if(k->time==0) {
printf("运行后进程[%s] 已完成状态为\"结束\".\n",k->name);
free(k);
}else
{
(k->priority)--;
(k->time)--;
printf("运行后优先数:%d 需要运行时间:%d\n",k->priority,k->time);
Q=sort(Q,k); /*调用sort函数*/
}
return Q;
}
void check(LinkQueue Q) /* 建立进程查看函数*/
{ PCB *pr;
pr=(PCB *)malloc(sizeof(PCB));
pr=Q.front->next;
printf("\n **** 输入的五个过程为:\n");
while(pr!=NULL) {
printf("\n 进程名:%s 状态:就绪优先数:%d 需要运行时
间:%d\n",pr->name,pr->priority,pr->time);
pr=pr->next;
}
}
void main()
{
int h=0;
LinkQueue P;
P=init();
P=input(P);
check(P);
while((P.front->next)!=NULL) {
h++;
k=P.front->next;
P.front->next=k->next;
k->next=NULL;
printf("\n 第%d次运行,被选中进程是:%s ",h,k->name);
P=running(P);
}
printf("\n\n 进程已经完成.\n");
}。