精华内容
下载资源
问答
  • ** 用C语言编程实现“先来先服务(FCFS)”算法模拟作业调度,输出平均周转时间平均带权周转时间** 要求:按作业的到达顺序输入各作业需要的运行时间,按算法调度输出平均周转时间。 例如(FCFS),输入:8(到达时间...

    ** 用C语言编程实现“先来先服务(FCFS)”算法模拟作业调度,输出平均周转时间、平均带权周转时间**

    要求:按作业的到达顺序输入各作业需要的运行时间,按算法调度输出平均周转时间。
    例如(FCFS),输入:8(到达时间0), 5(到达时间2),7(到达时间3),1(到达时间6)

    作业到达时间开始时间运行时间结束时间周转时间
    J100888
    J22851311
    J331372017
    J462012115

    提示:
    带权周转时间(Wi)=周转时间/运行时间
    平均带权周转时间=累计带权周转时间和/作业个数

    输出:
    平均周转时间=(8+(13-2)+(20-3)+(21-6))/4=51/4
    平均带权周转时间=(8/8+11/5+17/7+15/1)/4=5.157(大约)

    #include <stdio.h>
    
    int zhouzhuan(int ch[],int sh[],int num);
    int main()
    {
    	int ch[4]={0,2,3,6};   //到达时间的实参数组,可自己给出
    	int sh[4]={8,5,7,1};   //运行时间的实参数组,可自己给出
    	int num=sizeof(ch)/sizeof(ch[0]); //求出数组中的元素个数,即作业个数
    	zhouzhuan(ch,sh,num);
    }
    
    int zhouzhuan(int ch[] ,int sh[],int num) 
    {
    	int i;
    	int rt[100];  //运行时间
    	int at[100];  //到达时间
    	int et[100];  //结束时间
    	int ct[100];  //周转时间
    	float dq[100];  //带权周转时间=作业周转时间/作业执行时间
    	float totaltime; //周转时间
    	float avgtime; //平均周转时间
    	float totaldaiquan;//所有作业的带权周转时间累计和
    	float avgdaiquan;  //平均带权周转时间
    
    	for(i=0;i<num;i++)   
    	{
    		at[i]=ch[i];     //初始化到达时间数组
    		rt[i]=sh[i];     //初始化运行时间数组
    		printf("p%d:rt=%d,at=%d\n",i+1,rt[i],at[i]);
    	}
    
    	printf("FCFS:\n");
    
    	for(i=0;i<num;i++)
    	{
    		if(i==0)   //i=0时是第一个到达
    		{	
    			et[i]=rt[i]+at[i];   //第一个到达的,其结束时间就等于运行时间+到达时间
    
    		}
    
    		else if(at[i]<=et[i-1])  //当目前到达的作业在上一个作业结束前或刚好结束的时候就到达了,此时上一个作业的结束时间就是目前这个作业的开始时间
    		{
    			et[i]=et[i-1]+rt[i];    //结束时间=开始时间+运行时间 ,又因为这里的开始时间是上一个作业的结束时间,所以 结束时间=上一个作业的结束时间+这个作业的运行时间
    
    		}
    
           //可能前一个已经运行结束,但是后一个还没有到达(也可能) 
    		else 
    		{
    			et[i]=at[i]+rt[i];  //结束时间=开始时间+运行时间。因为这个作业,在它上一个作业完成之后都没有到达,所以她的开始时间就是自己的开始时间
    		}
    	    ct[i]=et[i]-at[i];   //周转时间=结束时间-到达时间
    		dq[i]=(float)ct[i]/(float)rt[i];	//带权周转时间=作业周转时间/作业执行时间
    		printf("p%d:到达时间=%d,运行时间=%d,结束时间=%d,周转时间=%d,带权周转时间=%.2f \n",i+1,at[i],rt[i],et[i],ct[i],dq[i]);
    	}
    
    	totaltime=0; //先设置一个初始值,不然计算会出错,赋垃圾值
    	totaldaiquan=0; //先设置一个初始值,不然计算会出错,赋垃圾值
    
    	for(i=0;i<num;i++)
    	{	
    		totaltime+=(float)ct[i];    //累计周转时间
    	    totaldaiquan+=(float)dq[i];  //累计带权周转时间
    
    	}
    
    
    	avgtime=totaltime/num;    //平均周转时间
    	avgdaiquan=totaldaiquan/num;   //累计平均周转时间
    
    	printf("Total cycling time of FCFS is:%.2f\n",totaltime);
    	printf("Average cycling time of FCFS is:%.2f.\n",avgtime);
    	printf("Total daiquan time of FCFS is:%.2f\n",totaldaiquan);
    	printf("Average daiquan time of FCFS is:%.2f\n",avgdaiquan);
    	return 0;
    	
    }
    
    展开全文
  • #include #include #include main() { char pn[10][10],t[10]; int arr[10],bur[10],star[10],finish[10],tat[10],wt[10],i,j,n,temp;... printf("\n平均带权周转时间:%.2f",(float)totwt/n); getch(); return 0; }
    #include<stdio.h>
    #include<string.h>
    #include<conio.h>
    main()
    {
        char pn[10][10],t[10];
        int arr[10],bur[10],star[10],finish[10],tat[10],wt[10],i,j,n,temp;
        int totwt=0,tottat=0;
    //clrscr();
        printf("请输入进程数量:");
        scanf("%d",&n);
        for(i=0; i<n; i++)
        {
            printf("请输入进程名称,到达时间,处理时间:");
            scanf("%s%d%d",&pn[i],&arr[i],&bur[i]);
        }
        for(i=0; i<n; i++)
        {
            for(j=0; j<n; j++)
            {
                if(arr[i]<arr[j])
                {
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                    temp=bur[i];
                    bur[i]=bur[j];
                    bur[j]=temp;
                    strcpy(t,pn[i]);
                    strcpy(pn[i],pn[j]);
                    strcpy(pn[j],t);
                }
    
            }
        }
        for(i=0; i<n; i++)
        {
            if(i==0)
                star[i]=arr[i];
            else
                star[i]=finish[i-1];
            wt[i]=star[i]-arr[i];
            finish[i]=star[i]+bur[i];
            tat[i]=finish[i]-arr[i];
        }
        printf("\n进程名称\t到达时间\t处理时间\t周转时间\t带权周转时间");
        for(i=0; i<n; i++)
        {
            printf("\n%s\t\t%3d\t\t%3d\t\t%6d\t\t%.2f",pn[i],arr[i],bur[i],tat[i],tat[i]*1.00/bur[i]);
            totwt+=tat[i]*1.00/bur[i];
            tottat+=tat[i];
        }
        printf("\n平均周转时间:%.2f",(float)tottat/n);
        printf("\n平均带权周转时间:%.2f",(float)totwt/n);
        getch();
        return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 调度算法—FCFS调度算法详解

    千次阅读 2020-06-11 18:45:17
    详解我自身理解的FCFS算法的实现思路,附代码

    FCFS概念介绍

    FCFS,全称First come First Serve,中文名:先来先调度算法。
    优点:简单,易实现;
    缺点:对短作业不公平;

    FCFS代码实现

    FCFS算法的实现步骤:
    1.确定进程块的变量
    2.创建进程队列,可以用链表等等
    3.依次计算每个进程并删除,输出

    CreateProcessQueue模块实现思路:

    • 利用循环体,创建进程并初始化;
    • 利用链表,将每个进程相关联;
    • 分情况,按有头节点和没头节点讨论,要注意每个进程的存储空间用p指针指向,所以p的值在每次循环中都会改变,不能用来指向下一个元素位置,这里用q来当游标;

    FCFS模块实现思路:

    • 利用循环体和if判断,确定进程是否被调度,未被调度则状态为‘f’,调用run模块调度;

    run模块实现思路:

    • 将状态改为‘t’,表示已调度,这里我进行了修改,进程调度完就删掉;
    • 计算周转时间,带权周转时间;

    FCFS完整调度算法代码:

    #include<stdio.h>
    #include<stdlib.h>
    #include<cstring>
    //进程控制块,数据结构 —结构体 
    typedef struct PCB{
    	char PcbName[10];
    	int PcbNo;
    	char State;
    	int ArrivalTime;
    	int StartTime;
    	int ServeTime;
    	int EndTime;
    	int TurnaroundTime;
    	float TakePowerTime;
    	struct PCB *next;
    }PCB;
    
    PCB *head = NULL,*q,*p;           //头节点 
    int time;				   //计时器 
    int n;                     //进程数
    
    //创建进程队列,采用链表结构
    void CreateProcessQueue(){
    	printf("创建进程数:\n");
    	scanf("%d",&n);
    	for(int i=0;i<n;i++){
    		p=(PCB *)malloc(sizeof(PCB));
    		p->StartTime = 0;
    		p->EndTime = 0;
    		p->TurnaroundTime = 0;
    		p->TakePowerTime = 0;
    		p->State = 'f'; 
    		p->ArrivalTime = 0;
    		printf("进程编号 进程名 到达时间 服务时间\n");
    		scanf("%d %s %d %d",&p->PcbNo,&p->PcbName,&p->ArrivalTime,&p->ServeTime);
            if(head==NULL)
            {
                head=p;q=p;time=p->ArrivalTime;
            }else{
            	q->next=p;
            	p->next=NULL;
            	q=p;
    		}
    	}
    } 
    
    void run(PCB *temp){
    	temp->State = 't';
    	time = temp->ArrivalTime>time?temp->ArrivalTime:time;
    	temp->StartTime = time;
    	temp->EndTime = temp->ServeTime+temp->StartTime;
    	time = temp->EndTime; 
    	temp->TurnaroundTime = temp->EndTime-temp->ArrivalTime;
    	temp->TakePowerTime = temp->TurnaroundTime/temp->ServeTime;
    	printf("进程编号 进程名 开始时间 结束时间 周转时间 带权周转时间\n");
    	printf("%d       %s     %d       %d       %d        %d\n",temp->PcbNo,temp->PcbName,temp->StartTime,temp->EndTime,temp->TurnaroundTime,temp->TakePowerTime);
    	p = temp->next;
    }
    
    //First Come First Serve
    void FCFS(){
    	p = head;
    	for(int i=0;i<n;i++){
    		if(p->State == 'f'){
    			run(p);
    		}
    	}
    }
    
    int main(){
    	CreateProcessQueue();
    	FCFS();
    	return 0;
    } 
    
    
    

    在这里插入图片描述

    展开全文
  • FCFS调度算法的思想就是谁先来就谁先受到服务,这与餐厅排队买饭是一个道理。 SJF调度算法是谁的服务时间短谁就先来。(举个例子,一个人山人海的餐厅里,都在那抢饭吃,很混乱,没人排队,谁吃的快谁就先吃) 代码...
    • FCFS调度算法的思想就是谁先来就谁先受到服务,这与餐厅排队买饭是一个道理。
    • SJF调度算法是谁的服务时间短谁就先来。(举个例子,一个人山人海的餐厅里,都在那抢饭吃,很混乱,没人排队,谁吃的快谁就先吃)

    代码

    首先需要定义一个结构体

    typedef struct pcb{
    	int id;       //进程id
    	int come;     //进程到达时间
    	int deal;     //进程服务时间
    	int finish;   //进程完成时间
    	int cycleTime;    //周转时间
    	float powerTime;  //带权周转时间
    }PCB;
    
    • 完成时间=服务时间+等待时间
    • 周转时间=完成时间-到达时间
    • 带权周转时间=周转时间/服务时间

    因此需要得到服务时间、到达时间与等待时间才可以得到上面的所有内容,但等待时间可以通过本次服务进程的开始时间与上次服务进程的完成时间得到,因此需要有的是开始时间与服务时间就可以得出所有内容

    FCFS调度算法需要对数组按come值进行从小到大排序(这里为了省事采用冒泡排序的思想,也可以用其他比较快的排序方法)

    for(i = 0;i < n - 1; i++){
    		for(j = i + 1; j < n; j++){
    			if(pr[i].come > pr[j].come){
    				temp = pr[i];
    				pr[i] = pr[j];
    				pr[j] = temp;
    			}
    		}
    	}
    

    排序完成后,对数组的第一个值进行计算(因为下一个进程的完成时间需要用到上一个进程的完成时间)

        pr[0].finish = pr[0].come + pr[0].deal;
    	pr[0].cycleTime = pr[0].finish - pr[0].come;
    	pr[0].powerTime = pr[0].cycleTime * 1.0 / pr[0].deal * 1.0;
    
    for(i = 1; i < n; i++){
    		if(pr[i].come < pr[i-1].finish)  //本次进程需要与上一个进程的完成时间进行比较
    			pr[i].finish = pr[i-1].finish + pr[i].deal;
    		else
    			pr[i].finish = pr[i].come + pr[i].deal;
    		pr[i].cycleTime = pr[i].finish - pr[i].come;
    		pr[i].powerTime = pr[i].cycleTime * 1.0 / pr[i].deal * 1.0;
    	}
    

    SJF调度算法需要注意到的是一开始需要找到先到达的进程(此时没进程需要处理,谁先来就先服务谁),需要找到come的最小值

    PCB temp;
    	for(i = 1; i < n; i++){
    		if(pr[0].come > pr[i].come)
    			k = i;
    	}
    	temp = pr[0];
    	pr[0] = pr[k];
    	pr[k] = temp;
    

    接下来与FCFS调度算法类似,也是排序,不过这次是根据deal值排序

    for(i = 1;i < n - 1; i++){    //第一个已经服务过了,从第二个开始
    		for(j = i + 1; j < n; j++){
    			if(pr[i].deal > pr[j].deal){
    				temp = pr[i];
    				pr[i] = pr[j];
    				pr[j] = temp;
    			}
    		}
    	}
    

    完整代码

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct pcb{
       int id;
       int come;
       int deal;
       int finish;
       int cycleTime;
       float powerTime;
    }PCB;
    void fcfs(PCB pr[],int n){
       int i,j;
       PCB temp;
       for(i = 0;i < n - 1; i++){
       	for(j = i + 1; j < n; j++){
       		if(pr[i].come > pr[j].come){
       			temp = pr[i];
       			pr[i] = pr[j];
       			pr[j] = temp;
       		}
       	}
       }
       pr[0].finish = pr[0].come + pr[0].deal;
       pr[0].cycleTime = pr[0].finish - pr[0].come;
       pr[0].powerTime = pr[0].cycleTime * 1.0 / pr[0].deal * 1.0;
       for(i = 1; i < n; i++){
       	if(pr[i].come < pr[i-1].finish)
       		pr[i].finish = pr[i-1].finish + pr[i].deal;
       	else
       		pr[i].finish = pr[i].come + pr[i].deal;
       	pr[i].cycleTime = pr[i].finish - pr[i].come;
       	pr[i].powerTime = pr[i].cycleTime * 1.0 / pr[i].deal * 1.0;
       }
       for(i = 0; i < n; i++){
       	printf("第%d个服务的是进程%d,开始服务时间%d,服务时间%d,结束时间%d,周转时间%d,带权周转时间%.2f\n",i + 1,pr[i].id,pr[i].come,pr[i].deal,pr[i].finish,pr[i].cycleTime,pr[i].powerTime);
       }
    }
    void sjf(PCB pr[], int n){
       int i,j,k = 0;
       PCB temp;
       for(i = 1; i < n; i++){
       	if(pr[0].come > pr[i].come)
       		k = i;
       }
       temp = pr[0];
       pr[0] = pr[k];
       pr[k] = temp;
       pr[0].finish = pr[0].come + pr[0].deal;
       pr[0].cycleTime = pr[0].finish - pr[0].come;
       pr[0].powerTime = pr[0].cycleTime * 1.0 / pr[0].deal * 1.0;
       for(i = 1;i < n - 1; i++){
       	for(j = i + 1; j < n; j++){
       		if(pr[i].deal > pr[j].deal){
       			temp = pr[i];
       			pr[i] = pr[j];
       			pr[j] = temp;
       		}
       	}
       }
       for(i = 1; i < n; i++){
       	if(pr[i].come < pr[i-1].finish)
       		pr[i].finish = pr[i-1].finish + pr[i].deal;
       	else
       		pr[i].finish = pr[i].come + pr[i].deal;
       	pr[i].cycleTime = pr[i].finish - pr[i].come;
       	pr[i].powerTime = pr[i].cycleTime * 1.0 / pr[i].deal * 1.0;
       }
       for(i = 0; i < n; i++){
       	printf("第%d个服务的是进程%d,开始服务时间%d,服务时间%d,结束时间%d,周转时间%d,带权周转时间%.2f\n",i + 1,pr[i].id,pr[i].come,pr[i].deal,pr[i].finish,pr[i].cycleTime,pr[i].powerTime);
       }
    }
    int main(){
       int n,i,choose,flag = 1;
       PCB pr[20];
       printf("请输入进程个数:");
       scanf("%d",&n);
       for(i = 0; i < n; i++){
       	printf("请输入第%d个的进程id与开始服务时间与服务时间",i + 1);
       	scanf("%d%d%d",&pr[i].id,&pr[i].come,&pr[i].deal);
       }
       while(flag){
       	printf("1、先来先服务\n2、短作业优先\n3、退出\n请输入选择:");
       	scanf("%d",&choose);
       	switch(choose){
       		case 1:fcfs(pr,n); break;
       		case 2:sjf(pr,n);	break;
       		default:flag = 0;	break;
       	}
       }
       return 0;
    }
    
    展开全文
  • 作业调度算法 先来先服务FCFS调度算法 作业调度的原理: 非抢占调度 把作业从外存调入内存 作业调度算法: 先来先服务FCFS 短作业优先SJF 静态优先级调度 高响应比优先调度 实验原理 作业调度算法:采用先来先服务...
  • 多种调度算法平均周转时间算例

    万次阅读 多人点赞 2016-04-22 11:19:22
    对下面的每种调度算法,分别计算作业的平均周转时间。(1)最高优先级优先 (2)时间片轮转(时间片为2分钟) (3)FCFS(作业到达顺序为C,D,B,E,A) (4)短作业优先[分析] 本题是一个关于作业调度算法的...
  • • 输出:每个作业的编号、作业开始执行时间、作业结束时间以及该调度算法平均等待时间平均周转时间。 1. job.txt说明: 第一行:作业数 轮转片大小 第二行以后:作业编号 到达时间 执行时间 优先级 2. 输出说明...
  • FCFS调度算法(FCFS,先来先服务,FIst Come Fiest Serve) 周转时间=作业完成时间-作业提交时间 平均周转时间=各作业周转时间之和 / 作业数 带权周转时间=作业周转时间 / 作业实际运行的时间=(作业完成时间-作业...
  • Python-FCFS调度算法

    千次阅读 2017-04-19 19:48:34
    操作系统作业:实现FCFS调度算法并用文件的方式读取进程信息和输出进程执行顺序,因为不要求使用的语言,所以就用我最喜欢的Python来写: 算法比较简单,以下是源码: import ast f = open("C:\\ff.txt","r") ff = ...
  • fcfs调度Prerequisites: FCFS... 先决条件: FCFS调度算法 什么是车队效应? (What is Convoy Effect?) In FCFS scheduling the burst time of the first job is the highest among all the other jobs so this si...
  • 已知一组进程P1、P2、P3……,及其到达时间和服务时间(参考下图),分别采用FCFS调度算法和SPF调度算法,求各个进程的完成时间周转时间、带权周转时间平均周转时间平均带权周转时间。 实验目的: 熟悉FCFS...
  • 操作系统:FCFS调度算法简单实现(c++)

    千次阅读 多人点赞 2019-10-15 19:23:00
    计算机操作系统:FCFS调度算法简单实现 由于本人(小白一个)一直以来一直想要写博客,加上最近学习操作系统,为了巩固自己的学习成果已经加深印象,现在决定开始写博客,可以说这是我的第一篇博客。 今天主要...
  • FCFS调度算法(FCFS,First Come First Serve) 算法思想: 主要从“公平的角度考虑”(类似于我们生活中排队买东西) 算法规则: 按照作业/进程到达的先后顺序进行服务 用于作业/进程调度: 用于作业调度时,考虑的是...
  • 首先我们必须明确:FCFS和SJF两种调度算法,只有在进程的完成时间计算上有一些区别,其他时间周转时间等)的计算都是相同的。 周转时间 周转时间=完成时间-到达时间 带权周转时间=周转时间/服务时间(除法运算...
  • 计算在单道程序环境下,采用先来先服务调度算法和短作业优先调度算法时的平均周转时间平均带权周转时间,并指出它们的调度顺序。 先来先服务(FCFS)调度算法: 是最简单的一种调度算法,它不仅可以用于高级...
  • //周转时间 float ts; int flag; }pcb; main() { void fcfs(pcb p[5]); void sjf(pcb p[5]); void pri(pcb p[5]); void scan(pcb *t); void fuzhi(pcb &a,pcb &b); int i; pcb b[5],p1[5]; for(i=...
  • 1 #include<stdio.h> 2 #include<stdlib.h> 3 typedef struct course{/*进程结构体*/ 4 char courseName;... 5 int startTime/*到达时间*/,serviceTime/*服务时间*/; 6 int...
  • 是对FCFS调度算法和短作业优先调度算法的一种综合平衡。 FCFS算法只考虑等待时间而未考虑运行时间的长短 短作业优先调度算法只考虑运行时间而未考虑等待时间的长短。 因此这两种调度算法在某些情况下都有不足之处。 ...
  • FCFS调度算法

    2015-06-04 10:51:13
    FCFS调度算法
  • 先来先服务的调度算法:最简单的调度算法,既可以用于作业调度 ,也可以用于程序调度,当作业调度中采用该算法时,系统将按照作业到达的先后次序来进行调度,优先从后备队列中,选择一个或多个位于队列头部的作业,...
  • 用目录中的四种调度算法分别求出相对应的平均带权周转时间 先用通俗的语言描述一下周转时间,用这道题目做例子,AAA到达时间为0,服务时间为3,如果系统立刻处理AAA,那么它的周转时间就是3−0=33-0=33−0=3,当然...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,621
精华内容 1,448
关键字:

fcfs调度算法平均周转时间