精华内容
下载资源
问答
  • FCFS

    2019-10-02 06:57:29
    FCFS算法的优缺点: 算法容易实现。但效率不高,只顾及作业等候时间,没考虑作业要求服务时间的长短。因此优待了长作业而不利于短作业;有利于CPU繁忙型作业,而不利于I/O繁忙型作业。 例如,三个作业同时到达系统...
    (First Come First Served)
    按照作业进入系统的先后次序来挑选作业,先进入系统的作业优先被挑选。
    FCFS算法的优缺点:
    算法容易实现。但效率不高,只顾及作业等候时间,没考虑作业要求服务时间的长短。因此优待了长作业而不利于短作业;有利于CPU繁忙型作业,而不利于I/O繁忙型作业。
    例如,三个作业同时到达系统并立即进入调度:
    作业名    所需CPU时间
    作业1    28
    作业2    9
    作业3    3
    若三个作业提交顺序改为作业2、1、3,平均作业周转时间约为29。采用FCFS算法,三个作业的周转时间分别为:28、37和40,因此,平均作业周转时间T = (28+37+40)/3 = 35
    ((9+37+40)/3≈29)
    若三个作业提交顺序改为作业3、2、1,平均作业周转时间约为18。
    ((3+12+40)/3≈18)
    FCFS调度算法的平均作业周转时间与作业提交的顺序有关。

    转载于:https://www.cnblogs.com/XACOOL/p/5652166.html

    展开全文
  • fcfs

    2016-06-14 11:48:00
    void fcfs(int i,int t,int n) {  a[0].finish=a[0].arrivetime+a[0].freetime;//给予a[0]初值  wordtime=a[0].finish;  a[0].turn=a[0].time;  a[0].average=(float)a[0].turn/a[0].time;  for(i=1;i;i++)//...

    #include<stdio.h>
    #include<stdlib.h>
    #define N 100


    typedef struct process
    {
     int time;  //需要时间
        char name;
     int end;
     
     int freetime;   //剩余剩余时间
     int arrivetime;   //到达时间
     int finish;        //完成时间
     int turn;          //周转时间
     double average;    //平均带权周转时间
    }P;

    P a[N],b;
    int wordtime=0;

    void fcfs(int i,int t,int n)
    {
     a[0].finish=a[0].arrivetime+a[0].freetime;//给予a[0]初值
     wordtime=a[0].finish;
        a[0].turn=a[0].time;
     a[0].average=(float)a[0].turn/a[0].time;
     for(i=1;i<n;i++)//执行
     {
      if(a[i].arrivetime<a[i-1].finish)
      {
       a[i].finish=a[i-1].finish+a[i].freetime;
       a[i].turn=a[i].finish-a[i].arrivetime;
      }
      else
      {
       a[i].finish=a[i].arrivetime+a[i].freetime;
       a[i].turn=a[i].time;
      }
      
      a[i].average=(float)a[i].turn/a[i].time;
      wordtime=a[i].finish;
     }
     
    }

    void main()
    {
     int i,j,n,sum=0;
     double average=0,turn=0;       
     printf("请输入进程个数: \n");
     scanf("%d",&n);
     getchar();
     for(i=0;i<n;i++)
     {
     
      printf("第%d个进程到达时间:",i+1);
      scanf("%d",&a[i].arrivetime);
      printf("第%d个的需要时间 :",i+1);
      scanf("%d",&a[i].time);
      printf("\n");

      a[i].freetime=a[i].time;//剩余时间赋值
     
     
     }//输入数据
     
     for(i=0;i<n;i++)
     {
      for(j=i+1;j<n;j++)
      {
       if(a[j].arrivetime<a[i].arrivetime)
       {
        b=a[i];
        a[i]=a[j];
        a[j]=b;
       }
       else if(a[j].arrivetime==a[i].arrivetime)
       {
        if(a[i].time>a[j].time)
        {
         b=a[i];
         a[i]=a[j];
         a[j]=b;
        }
       }
      }
     }//排序
     fcfs(i,j,n);
     
     printf("完成时间\t周转时间\t带权周转\n");
     for(i=0;i<n;i++)
      printf("%d\t\t%d\t\t%.2f\n",a[i].finish,a[i].turn,a[i].average);
     
        for(i=0;i<n;i++)
     {
      turn=turn+(float)a[i].turn;
      average=average+(float)a[i].turn/a[i].time;
     }
     turn=turn/n;
     average=average/n;
     printf("平均周转     平均带权周转\n");
        printf("%.2f\t\t%.2f\n",turn,average);
     
    }

    转载于:https://www.cnblogs.com/guo2016/p/5583551.html

    展开全文
  • FCFS 为受让人操作系统 Fransisco Jose de Caldas 地区大学实施规划算法 FCFS 项目 要求 将模拟一分钟的“加工” 进程的到达时间是随机的。 随机化过程的突发时间。 必须制作图表。 突发时间、等待时间和平均...
  • fcfs调度Prerequisites: FCFS scheduling algorithm 先决条件: FCFS调度算法 什么是车队效应? (What is Convoy Effect?) In FCFS scheduling the burst time of the first job is the highest among all the ...

    fcfs调度

    Prerequisites: FCFS scheduling algorithm

    先决条件: 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 situation is referred to as a convoy effect.

    FCFS调度中,第一个作业的突发时间在所有其他作业中最高,因此这种情况被称为“ 车队效应”

    • For example, there is one CPU intensive process (which has large burst time) in the ready queue, and many more other processes comparatively fewer burst times but are Input/ Output (I/O) bound processes that mean processes need I/O operations frequently.

      例如,就绪队列中有一个CPU密集型进程(突发时间较长),其他进程的突发时间相对较少,但它们是受输入/输出(I / O)约束的进程,这意味着进程需要I / O操作经常。

    • Let's take an example of real life, suppose a convoy is passing through the road. So, other persons may get blocked until it passes completely.

      让我们以现实生活为例,假设一个车队正在穿越马路。 因此,其他人可能会被阻止直到其完全通过。

    • If the CPU currently executing the process that has higher burst time at the front end of the ready queue then the processes of lower burst time may get blocked by the currently running process which means they may never get the CPU if the job in the execution has a very high burst time. This is known as the convoy effect or starvation.

      如果当前正在执行的CPU在就绪队列的前端具有较高的突发时间,则较低突发时间的进程可能会被当前正在运行的进程阻塞,这意味着如果执行中的作业具有突发时间非常长。 这被称为车队效应或饥饿

    Convoy Effect in FCFS Scheduling


    Convoy Effect

    车队效应

    Steps are as follows,

    步骤如下,

    • Firstly allocate the CPU time to the I/O bound processes because they are less CPU intensive, they will take less time to execute and after execution goes to the I/O queues.

      首先,将CPU时间分配给受I / O约束的进程,因为它们占用的CPU较少,它们将花费较少的时间执行,并且在执行后转到I / O队列。

    • Now, allocated the CPU time to the CPU intensive process because its burst time is high, it takes a long time to execute.

      现在,由于其突发时间很长,所以将CPU时间分配给了CPU密集型进程,因此执行时间很长。

    • During the execution of the CPU intensive process, the I/O bound processes complete their I/O operations and are a return to ready queue.

      在执行CPU密集型进程期间,受I / O约束的进程完成其I / O操作,并且返回到就绪队列。

    • However, the CPU intensive process still hasn’t finished its execution so the I/O bound processes are waiting in the ready queue. At this time I/O devices being idle.

      但是,占用大量CPU的进程仍未完成执行,因此受I / O约束的进程在就绪队列中等待。 此时,I / O设备处于空闲状态。

    • When the CPU intensive process finishes its execution, it is sent to the I/O queue so that it can access an I/O device.

      当CPU密集型进程完成执行后,将其发送到I / O队列,以便它可以访问I / O设备。

    • Meanwhile, move back to the I/O queue as these processes get their required CPU time.

      同时,当这些进程获得所需的CPU时间时,请移回I / O队列。

    • However, I/O bound processes are waiting because the CPU intensive process is still accessing an I/O device. So, now the CPU is sitting idle.

      但是,由于CPU密集型进程仍在访问I / O设备,因此受I / O约束的进程正在等待。 因此,现在CPU处于空闲状态。

    Example:

    例:

    In Example, We have 3 processes named P1, P2, and P3. Among these three processes, P1 has the highest burst time.

    在示例中,我们有3个名为P1P2P3的进程。 在这三个过程中, P1具有最高的突发时间。

    We can calculate the Turnaround time by Turn Around Time = Completion Time - Arrival Time.

    我们可以通过周转时间=完成时间-到达时间来计算周转时间

    Calculate the waiting time by the formula: Waiting Time = Turn Around Time - Burst Time.

    通过以下公式计算等待时间: 等待时间=转身时间-爆发时间

    • In the first phase, the process P1 arrives at the first in the queue. The process P1 has the highest burst time among all.

      在第一阶段,过程P1到达队列中的第一阶段。 在所有过程中,过程P1具有最高的突发时间。

    • According to the FCFS scheduling algorithm, the process comes the first CPU will execute that process first. So, here CPU will execute process P1.

      根据FCFS调度算法 ,该进程首先由CPU首先执行。 因此,此处CPU将执行处理P1

    • In this schedule, the average waiting time of the system will also be very high. This is because of the convoy effect or starvation.

      在此时间表中,系统的平均等待时间也将非常长。 这是由于车队效应或饥饿

    • The other processes P2, P3 have to wait for their execution by the processor for 50 units of time and the burst time of these two processes is very small. This schedule suffers from starvation.

      其他进程P2P3必须等待处理器执行它们的时间为50个单位 ,这两个进程的突发时间非常短。 这个日程安排挨饿了

    Process IdArrival timeBurst timeTurnaround timeWaiting time
    P1035350
    P2123634
    P3144036
    流程编号 到达时间 爆发时间 周转时间 等待的时间
    P1 0 35 35 0
    P2 1个 2 36 34
    P3 1个 4 40 36
    Convoy Effect in FCFS Scheduling | Gantt Chart


    Gantt Chart

    甘特图

    Average waiting Time = 0+34+36/3 = 70/3 = 23.33

    平均等待时间= 0 + 34 + 36/3 = 70/3 = 23.33

    • In the second phase, the problem of starvation would not occur only if the other processes P2 and P3 would have arrived earlier and process P1 would have arrived at the last.

      在第二阶段,仅当其他进程P2P3较早到达而进程P1最终到达时,才会出现饥饿问题。

    • Let's take another example where process P1 will arrive after processes P2 and P3.

      让我们再举一个例子,其中进程P1将在进程P2P3之后到达。

    Process IdArrival timeBurst timeTurnaround timeWaiting time
    P1135405
    P20220
    P30461
    流程编号 到达时间 爆发时间 周转时间 等待的时间
    P1 1个 35 40 5
    P2 0 2 2 0
    P3 0 4 6 1个
    Convoy Effect in FCFS Scheduling | Gantt Chart


    Gantt Chart

    甘特图

    • In this example, we can see the waiting times of both phases. However, the length of the schedule is the same that is 41 units but the waiting time will be lesser in this schedule.

      在此示例中,我们可以看到两个阶段的等待时间。 但是,时间表的长度相同,为41个单位,但是此时间表中的等待时间会更少。

      Average waiting Time = 5+1+0/3 = 6/3 = 2

      平均等待时间= 5 + 1 + 0/3 = 6/3 = 2

    如何避免车队效应? (How to avoid Convoy Effect?)

    Preemptive scheduling like round-robin scheduling can be used to avoid Convoy Effect as in these algorithms every process will be given an equal chance to access the CPU. By using these smaller processes don’t have to wait much for CPU time – making their execution faster and leading to fewer resources sitting idle.

    像循环调度这样的抢占式调度可用于避免Convoy效应,因为在这些算法中,每个进程都具有访问CPU的平等机会。 通过使用这些较小的进程,不必花太多时间等待CPU时间-使其执行速度更快,并减少了空闲资源。

    翻译自: https://www.includehelp.com/operating-systems/convoy-effect-in-fcfs-scheduling.aspx

    fcfs调度

    展开全文
  • FCFS的调度算法

    2015-06-04 10:51:13
    FCFS的调度算法
  • FCFS算法

    万次阅读 2018-10-29 12:34:30
    原理:  按照作业进入系统的先后次序来挑选作业,先进入系统的作业优先...FcFs.h: #define _CRT_SECURE_NO_WARNINGS #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct PCB { ...

    原理:

              按照作业进入系统的先后次序来挑选作业,先进入系统的作业优先被挑选。

     

    用c语言写的,采用单链表来模拟PCB,实现CPU调用进程。

     

    FcFs.h:

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct PCB
    {
    	char ID[15];//进程名字
    	int arrive_time; //进程到达时间
    	int work_time;//进程服务时间
    	int start_time; //进程开始时间
    	int finish_time;//进程完成时间
    	int turnover_time;//周转时间
    	double Wturnover_time;//加权周转时间
    	int data;//执行顺序
    	char sign;//标记 N 表示已排序,不能进入。Y表示没排序,可以进入。
    	struct PCB *next;
    }PCB,*P_PCB;
    
    //接收所有进程,形成PCB链表
    int Enter(P_PCB start)
    {
    	int process_sum = 0;//进程的总数
    	printf("请输入进程的个数:");
    	scanf("%d", &process_sum);
    	start->data = process_sum;//头指针装入了进程总数
    
    	for (int i = 0; i < process_sum; i++)
    	{
    		//录入第i个进程的信息
    		P_PCB newHead;
    		newHead = (P_PCB)malloc(sizeof(PCB));//新的节点
    		printf("请输入进程%d的名字:", i+1);
    		scanf("%s", newHead->ID);
    		printf("请输入进程%d的到达时间;", i+1);
    		scanf("%d", &newHead->arrive_time);
    		printf("请输入进程%d的服务时间;", i+1);
    		scanf("%d", &newHead->work_time);
    		system("cls");
    
    		newHead->next = start->next;
    		start->next = newHead;
    	}
    	return 0;
    }
    
    //根据进程到达时间对除ID和arrive_time和work_time外其他值赋值
    int Rank(P_PCB start)
    {
    	int temp, atime, ftime;
    	P_PCB m= NULL,p,q;//p为了找一个sign是Y的节点把arrive_time给temp,q是和其他的arrive_time比较的跟踪节点,m是最小temp的跟踪
    	//对所有节点的sign赋值
    	p = start->next;
    	for(int i=0;i<start->data;i++)
    	{
    		p->sign = 'Y';
    		p = p->next;
    	}
    	//给每一个节点赋了 data值
    	for (int i=0;i< start->data ;i++)
    	{
    		//arrive_time找最小值
    		p = start->next;
    		while (p->next != NULL)
    		{
    			if (p->sign == 'Y')
    			{
    				temp = p->arrive_time;
    				m = p;break;
    			}
    		}
    		q = p;
    		while ( q->next != NULL)
    		{
    			q = q->next;
    			if (q->sign == 'Y'&& temp > q->arrive_time)
    			{
    				temp = q->arrive_time;
    				m = q;
    			}
    		}
    		m->data = i + 1;
    		m->sign = 'N';
    
    		//根据data值对start_time和finish_time和sign赋值
    		if (m->data == 1)
    		{
    			m->start_time = m->arrive_time;//开始时间
    			m->finish_time = m->work_time;//结束时间
    			atime = m->start_time;
    			ftime = m->finish_time;
    			m->turnover_time = m->finish_time - m->arrive_time;//周转时间(完成-到达)
    			m->Wturnover_time = (double)m->turnover_time / m->work_time;//加权周转时间
    		}
    		else
    		{
    			if (m->arrive_time <= ftime)
    			{
    				m->start_time = ftime;//开始时间
    				m->finish_time = m->work_time+ m->start_time;//结束时间
    				atime = m->start_time;
    				ftime = m->finish_time;
    				m->turnover_time = m->finish_time - m->arrive_time;//周转时间(完成-到达)
    				m->Wturnover_time = (double)m->turnover_time / m->work_time;//加权周转时间
    			}
    			else
    			{
    				m->start_time= m->arrive_time;//开始时间
    				m->finish_time = m->work_time+ m->start_time;//结束时间
    				atime = m->start_time;
    				ftime = m->finish_time;
    				m->turnover_time = m->finish_time - m->arrive_time;//周转时间(完成-到达)
    				m->Wturnover_time = (double)m->turnover_time / m->work_time;//加权周转时间
    			}
    		}
    	}
    	return 0;
    }
    
    //输出所有进程信息
    void A(P_PCB start)
    {
    	P_PCB p ;
    	for (int i = 0; i < start->data; i++)
    	{
    		p = start;
    		while (p->next!= NULL)
    		{
    			p = p->next;
    			if (p->data == i + 1)
    			{
    				printf("进程名字%s  ,到达时间:%d  ,服务时间:%d     ", p->ID, p->arrive_time, p->work_time);
    				printf("开始时间:%d ,完成时间:%d ,周转时间:%d ,加权周转时间:%lf\n", p->start_time, p->finish_time, p->turnover_time, p->Wturnover_time);
    				printf("+++++++++++++++++++++++++++++++\n");
    			}
    		}
    	}
    }
    
    //模拟cpu运行
    void B(P_PCB start)
    {
    	P_PCB q;
    	for (int m = 0; m < start->data; m++)
    	{
    		q = start;
    		for (int i = 0; i < start->data; i++)
    		{
    			q = q->next;
    			if (q->data == m + 1)
    			{
    				printf("在%d时刻:%s进程开始执行。\n", q->start_time, q->ID);
    				for (int j = q->start_time; j <= q->finish_time; j++)
    				{
    					printf("在%d时刻:%s进程正在执行。\n", j, q->ID);
    				}
    				printf("在%d时刻:%s进程结束执行。\n", q->finish_time, q->ID);
    				break;
    			}
    		}
    	}
    }
    
    //函数调用
    int Show(P_PCB start)
    {
    	int a = 0;
    	P_PCB p = start;
    	printf("请录入进程的信息:\n");
    	Enter(start);
    	Rank(start);
    	while (1)
    	{
    		printf("请选择你要展示的效果:\n");
    		printf("1.输出所有进程的信息。\n");
    		printf("2.模拟cpu工作状态。\n");
    		printf("3.退出.\n");
    		scanf("%d", &a);
    		switch (a)
    		{
    		case 1: A(start); break;
    		case 2: B(start); break;
    		case 3: exit(0); break;
    		default:break;
    		}
    		system("pause");
    		system("cls");
    	}
    	return 0;
    }
    
    
    
    

    FcFs_test.cpp:

    #include"FcFs.h"
    
    int main()
    {
    	P_PCB start;
    	start = (P_PCB)malloc(sizeof(PCB));//头结点
    	start->next = NULL;
    	Show(start);
    	return 0;
    }

     

     

    展开全文
  • fcfs调度In the FCFS scheduling, we consider that all the processes or jobs are the CPU bound jobs (if any process spends most of its time simply using the CPU or doing calculations, so this process is...
  • FCFS算法设计

    千次阅读 2018-11-12 19:57:03
    FCFS先来先服务算法FCFS的基本思想我的设计思路图解我的代码: FCFS的基本思想 先来先服务就是一个思想,谁先到先执行谁,也就是谁在任务队列等待时间越长越先被执行(相同度量下,就是在考虑谁先出队就要重新更新一...
  • FCFS算法 c++语言

    2010-10-26 15:06:05
    FCFS算法 c++语言FCFS算法 c++语言FCFS算法 c++语言
  • 操作系统实验报告实验一:作业调度学院:软件学院专业:软件工程班级:软件工程12-01姓名:***学号:541213460157实验一:作业调度实现FCFS和SJF调度算法【实验题目】:编写程序,实现FCFS和SJF算法,模拟作业调度过...
  • fcfs调度算法The FCFS, which stands for First Come First Serve Scheduling Algorithm, is a non-preemptive scheduling algorithm, which means that if a process once starts executing in the processor, then...
  • FCFS实现磁盘调度算法

    2020-06-03 09:29:17
    FCFS算法根据进程请求访问磁盘的先后顺序进行调度,这是一种最简单的调度算法。该算法的优点是具有公平性。如果只有少量进程需要访问,且大部分请求都是访问簇聚的文件扇区,则有望达到较好的性能;但如果有大量进程...
  • FCFS-CPU-调度程序-源码

    2021-03-04 10:31:50
    FCFS-CPU-调度程序
  • FCFS和SSTF算法实现

    2013-11-30 22:58:36
    FCFS和SSTF java算法实现
  • FCFS先来先服务

    2013-11-27 09:16:14
    FCFS先来先服务操作系统
  • fcfs+设计费算法Java

    2018-08-23 20:35:04
    fcfs+设计费算法Java 只有Java可运行.
  • FCFS和SJF调度算法java实现,这里输出界面友好,主要用eclispe编写的,计算了各个进程的性能指标和平均轮转时间等参数。
  • FCFS 磁盘调度

    2017-05-12 10:54:29
    /*FCFS调度*/ #include #include #define N 100 typedef struct Pro{  float aim;  float change; }Pro; Pro P[N]; void InputData(Pro a[],int n){  for(int i=0;i  printf("第%d进程位置",i+1);  scanf(
  • 操作系统中的FCFS算法

    2015-04-15 13:42:49
    操作系统中的FCFS算法,用C语言进行编写,代码简单明了,并且实现了六十进制和百进制之间的转换,易于初学操作系统的人更加了解FCFS算法
  • xv6 FCFS Scheduling

    2019-04-18 08:29:04
    学习xv6 FCFS(First Come First Serve) Scheduling 1.FCFS Scheduling   First come first serve (FCFS) scheduling algorithm simply schedules the jobs according to their arrival time. The job which comes...
  • linux进程fcfs进程调度算法c++模拟实现,自定义结构体,依据到达时间对进程先后顺序排序并输出排序结果(进程名,到达时间,服务时间)
  • fcfs调度算法Here you will get C/C++ program for first come first served (fcfs) scheduling algorithm. 在这里,您将获得用于先到先得(fcfs)调度算法的C / C ++程序。 What isFirst Come First Served (FCFS) ...
  • Java 模拟实现操作系统中 进程调度中的先来先服务算法(FCFS) ,源代码注释清晰,操作简单。。。。。
  • 实 现 FCFS 和 SJ F 调 度算法 操作系统实验报告 实验一作业调度 学院软件学院 专业软件工程 班级软件工程12-01 姓名 * 学号541213460157 实验一作业调度 实现FCFS和SJF调度算法 实验题目编写程序实现FCFS和SJF算法...
  • 操作系统中的先来先服务算法fcfs和多级反馈队列调度算法mfq
  • FCFS调度算法(FCFS,先来先服务,FIst Come Fiest Serve) 周转时间=作业完成时间-作业提交时间 平均周转时间=各作业周转时间之和 / 作业数 带权周转时间=作业周转时间 / 作业实际运行的时间=(作业完成时间-作业...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,727
精华内容 3,890
关键字:

fcfs