精华内容
下载资源
问答
  • 操作系统实验报告实验一:作业调度学院:软件学院专业:软件工程班级:软件工程12-01姓名:***学号:541213460157实验一:作业调度实现FCFS和SJF调度算法【实验题目】:编写程序,实现FCFS和SJF算法,模拟作业调度过...

    操作系统实验报告

    实验一:作业调度

    学院:

    软件学院

    专业:

    软件工程

    班级:

    软件工程12-01

    姓名:

    ***

    学号:541213460157

    实验一:作业调度

    实现FCFS和SJF调度算法

    【实验题目】:编写程序,实现FCFS和SJF算法,模拟作业调度过 程,加深对作业调度的理解。

    【实验内容】

    实现FCF和SJF调度算法。

    -数据结构设计(JCB,后备作业队列)

    -算法实现与模拟(排序、调度)

    -输出调度结果,展示调度过程并解释

    【实验要求】

    设计作业控制块(JCB)的数据结构

    -应包含实验必须的数据项,如作业ID、需要的服务时间、进入系 统时间、完成时间,以及实验者认为有必要的其他数据项。

    实现排序算法(将作业排队)

    -策略1:按“进入系统时间”对作业队列排序(FCFS)

    -策略2:按“需要的服务时间”对作业队列排序(SJF)

    实现调度过程模拟

    (1)每个作业用一个JCB表示,如果模拟FCFS,按策略1将作业排队, 如果模拟SJF,按策略2将作业排队

    (2)选择队首的作业,将其从后备队列移出。

    (3)(作业运行过程,在本实验中,无需实现,可认为后备队列上的 作业一但被调度程序选出,就顺利运行完毕,可以进入第 4步)

    (4)计算选中作业的周转时间

    (5)进行下一次调度(去往第2步)

    实现结果输出

    -输出作业状态表,展示调度过程

    ?初始作业状态(未调度时)

    ?每次调度后的作业状态

    5?撰写实验报告

    -包含实验要求中1~4项内容,要求有设计图(结构图/流程图)和 源代码。

    -注明使用的编程语言和环境。

    注意事项

    ?实验中注重实现算法本质(先来先服务,短作业优先)。

    ?两个算法可以使用一套程序,差别只在队列的排序方式。

    ?这两个算法也可适用于进程调度。关于作业调度和进程调度的区 别,只要求概念上理解清楚,不要求实现。

    设计作业控制块(JCB)的数据结构

    每个作业由一个作业控制块JCB表示,JCB可以包含如下信息:作 业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针 等等。具体结构如下:

    typedef struct jcb{

    char n ame[10];/* 作业名 */

    charstate;/*

    char

    state;

    /*作业状态*/

    int ts; /*提交时间*/

    float

    super;

    /* 优先权 */

    int

    tb; /*

    开始运行时间

    */

    int

    tc;/*

    完成时间

    */

    float

    ti;

    /* 周转时间

    */

    float wi; /* 带权周转时间 */

    int ntime; /* 作业所需运行时间*/

    char resource[10]; /* 所需资源*/

    struct jcb *n ext;/* 结构体指

    针*/

    } JCB;

    JCB *p,*tail二NULL,*head二NULL;

    作业的状态可以是等待 W(Wait)、运行R(Run)和完成F(Finish) 三种状态之一。每个作业的最初状态总是等待W,组成一个后备队

    列等待,总是首先调度等待队列中队首的作业。

    本实验采用链表的形式存放各后备队列当中的作业控制块,各个

    等待的作业按照提交时刻的先后次序排队。当一个作业进入系统时, 就为其动态建立一作业控制块(JCEB,挂入后备队列尾部。当作业 调度时,从后备队列中按某种调度算法选择一作业,让其进入主存以

    便占用CP执行。

    每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转

    时间和带权周转时间,这一组作业完成后要计算并打印这组作业的平

    均周转时间、带权平均周转时间

    设计图

    咖r/有的JCB

    KJCB按作业SB仝的时劇的先旨Ti序捧队 时问?Tj =0

    调度{认皆的作亚投入运行*

    电更改駅甘擂针*厘作亚的悴第R. 1B住 作业痢觸商tsm nvw>

    紜行作业i的完咸耐刻 鹿.周疑ffWH

    Ti带枚周转耐闻WL

    気咖刻运行旳劃+运丽MB ffiWWfffl Ti=^WSJ"?5?WSJ 带投周仙间 伽=周转时词寻运<?时间

    JCSWf可重T的僵

    时舜弟7呂应姐作业周祐酣何及寿权平均周转时间

    编程语言:C++

    编程环境:Visual C++ 6.0

    程序代码:

    FCFS :

    #in elude

    using n amespace std;

    class Fcfs {

    private:

    int num[10];〃作业编号

    double arriveTime[10]; // 到达时间

    double startTime[10]; //开始时间,进内存时间

    double workTime[10];// 工作时间

    double fini shTime[10]; // 完成时间

    double c

    展开全文
  • FCFS和SJF进程调度调度算法.pdf
  • 实 现 FCFS SJ F 调 度算法 操作系统实验报告 实验一作业调度 学院软件学院 专业软件工程 班级软件工程12-01 姓名 * 学号541213460157 实验一作业调度 实现FCFS和SJF调度算法 实验题目编写程序实现FCFS和SJF算法...
  • FCFS和SJF调度算法java实现,这里输出界面友好,主要用eclispe编写的,计算了各个进程的性能指标平均轮转时间等参数。
  • FCFS和SJF作业调度算法模拟 带源代码 带源程序 可以直接使用
  • c语言实现 FCFS和SJF调度算法 在vc6.0已经调试通过
  • python编写FCFS和SJF

    千次阅读 2017-04-17 08:55:33
    python编写FCFS和SJF 上课老师要求不管用什么语言写出先来先服务FCFS和短作业SJF服务,贪图时间,就用了python来写。网上资源也少。没有什么难点,纯属逻辑问题。怕我自己会忘记,所以记下来以备后用。 使用的版本...

    FCFS和SJF

    上课老师要求不管用什么语言写出先来先服务FCFS和短作业SJF服务,贪图时间,就用了python来写。网上资源也少。没有什么难点,纯属逻辑问题。怕我自己会忘记,所以记下来以备后用。
    使用的版本是python3.0
    软件是pycharm

    #coding:utf-8
    ###python3.5
    __author__ = 'DD'
    global N
    N = 5
    pcb = []
    #输入函数
    def inPcb():
        global N
        i=0
        while (i < N):
            print("****************************************")
            pName = input("请输入进程名 :")                 #进程名
            inTime = input("请输入进入时间:")               #进入时间
            serverTime = input("请输入服务时间:")           #服务时间
            #数据按顺序存放到列表中 startTime=开始时间 finishTime=完成时间 zzTime=周转时间 dqzzTime=带权周转时间
            #          进程名 进入时间 服务时间  开始 完成 周转 带权
            pcb.append([pName, inTime, serverTime, 0,  0,   0,    0])
            i = i + 1
    #先来先服务
    def fcfs():
        global N
        pcb.sort(key=lambda x:x[1], reverse=False)  ##升序排序   x:x[1] 按照进入时间排序
        i = 0
        for i in range(N):
            if(i==0):
                startTime = int(pcb[i][1])
                pcb[i][3] = startTime
                pcb[i][4] = startTime + int(pcb[i][2])
            else:
                startTime = pcb[i-1][4]
                pcb[i][3] = startTime
                pcb[i][4] = startTime + int(pcb[i][2])
            i = i + 1
        for i in range(N):     #计算周转时间和带权周转时间
            pcb[i][5] = float(pcb[i][4]) - int(pcb[i][1])    #周转时间
            pcb[i][6] = float(pcb[i][5]) / int(pcb[i][2])    #带权周转时间
            i = i + 1
        #讲结果输出出来
        pcb.sort(key=lambda x:x[0], reverse=False)     ##升序排序  按照进程名排序
        print('运行结果:')
        for i in range(N):
            print("进程名:%s 进入时间:%d 服务时间:%d 开始时间:"
                  "%d 完成时间:%d 周转时间:%d 带权周转时间:%.2f"
                    % (pcb[i][0],int(pcb[i][1]),int(pcb[i][2]),int(pcb[i][3]),
                       int(pcb[i][4]),int(pcb[i][5]),float(pcb[i][6])))
            i +=1
    #短作业优先
    def sjf():
        sjf_pcb=pcb
        temp_pcb = pcb[1:len(sjf_pcb)]   #切片 临时存放后备队列  len(sjf_pcb)获取长度。
        temp_pcb.sort(key=lambda x:x[2], reverse=False)  ##对后背队列 按照服务时间排序
        sjf_pcb[1:len(sjf_pcb)]=temp_pcb
        i = 0
        for i in range(N):
            if(i==0):
                startTime = int(sjf_pcb[0][1])
                pcb[0][3] = startTime
                pcb[0][4] = startTime + int(sjf_pcb[0][2])
            else:
                startTime = sjf_pcb[i-1][4]
                pcb[i][3] = startTime
                pcb[i][4] = startTime + int(sjf_pcb[i][2])
                i = i + 1
        for i in range(N):
            sjf_pcb[i][5] = int(sjf_pcb[i][4]) - int(sjf_pcb[i][1])    #周转时间
            sjf_pcb[i][6] = float(sjf_pcb[i][5]) / int(sjf_pcb[i][2])    #带权周转时间
            i = i + 1
        #输出结果
        pcb.sort(key=lambda x:x[0], reverse=False)     ##升序排序  按照进程名排序
        print('短作业优先SJF运行结果:')
        for i in range(N):
            print("进程名:%s 进入时间:%d 服务时间:%d 开始时间:"
                  "%d 完成时间:%d 周转时间:%d 带权周转时间:%.2f"
                    % (sjf_pcb[i][0],int(sjf_pcb[i][1]),int(sjf_pcb[i][2]),int(sjf_pcb[i][3]),
                       int(sjf_pcb[i][4]),float(sjf_pcb[i][5]),float(sjf_pcb[i][6])))
    if __name__ == '__main__':
        inPcb()
        fcfs()
        sjf()
    

    结果如下显示:

    ****************************************
    请输入进程名 :a
    请输入进入时间:0
    请输入服务时间:4
    ****************************************
    请输入进程名 :b
    请输入进入时间:1
    请输入服务时间:3
    ****************************************
    请输入进程名 :c
    请输入进入时间:2
    请输入服务时间:5
    ****************************************
    请输入进程名 :d
    请输入进入时间:3
    请输入服务时间:2
    ****************************************
    请输入进程名 :e
    请输入进入时间:4
    请输入服务时间:4
    运行结果:
    进程名:a 进入时间:0 服务时间:4 开始时间:0 完成时间:4 周转时间:4 带权周转时间:1.00
    进程名:b 进入时间:1 服务时间:3 开始时间:4 完成时间:7 周转时间:6 带权周转时间:2.00
    进程名:c 进入时间:2 服务时间:5 开始时间:7 完成时间:12 周转时间:10 带权周转时间:2.00
    进程名:d 进入时间:3 服务时间:2 开始时间:12 完成时间:14 周转时间:11 带权周转时间:5.50
    进程名:e 进入时间:4 服务时间:4 开始时间:14 完成时间:18 周转时间:14 带权周转时间:3.50
    短作业优先SJF运行结果:
    进程名:a 进入时间:0 服务时间:4 开始时间:0 完成时间:4 周转时间:4 带权周转时间:1.00
    进程名:b 进入时间:1 服务时间:3 开始时间:6 完成时间:9 周转时间:8 带权周转时间:2.67
    进程名:c 进入时间:2 服务时间:5 开始时间:13 完成时间:18 周转时间:16 带权周转时间:3.20
    进程名:d 进入时间:3 服务时间:2 开始时间:4 完成时间:6 周转时间:3 带权周转时间:1.50
    进程名:e 进入时间:4 服务时间:4 开始时间:9 完成时间:13 周转时间:9 带权周转时间:2.25
    展开全文
  • Go编写调度算法FCFS和SJF
    package main
    
    import (
    	"fmt"
    	"time"
    )
    
    var (
    	A       []BTNode
    	n       int //任务个数
    	a, b    int
    	s       []int
    	visited []bool
    )
    
    type BTNode struct { //定义结构体
    	Time   int
    	Length int
    }
    
    func Init() bool { //初始化切片
    
    	s = make([]int, n)
    	visited = make([]bool, n)
    	visited[0] = true
    
    	for i := 0; i < n; i++ {
    		fmt.Scanln(&a, &b)
    		v := BTNode{a, b}
    		A = append(A, v)
    	}
    	return true
    }
    
    func FCFS() (int, float32) { //先来先服务
    	sum := A[0].Time
    	var sum_t float32 = 0.0
    
    	for i := 0; i < n; i++ {
    		sum = sum + A[i].Length
    		s[i] = sum - A[i].Time
    		sum_t = sum_t + float32(s[i])/float32(A[i].Length)
    	}
    	return sum, sum_t / float32(n)
    
    }
    
    func Min() (int, int) {
    	min := 9999 //定义一个比较大的数
    	var index int = 0
    	for i := 0; i < n; i++ {
    		if visited[i] == false {
    			if min > A[i].Length {
    				index = i
    				min = A[i].Length
    			}
    		}
    	}
    	visited[index] = true //设置为访问过
    
    	return index, min
    }
    
    func SJF() (int, float32) { //短作业优先
    	sum := A[0].Time + A[0].Length
    
    	var sum_t float32 = 1
    	var temp int = 0
    	var index int = 0
    
    	for i := 1; i < n; i++ {
    		index, temp = Min()
    		sum = sum + temp
    		s[index] = sum - A[index].Time
    		sum_t = sum_t + float32(s[index])/float32(temp)
    	}
    	return sum, sum_t / float32(n)
    
    }
    
    func main() {
    	var total_time int
    	var average_time float32
    	fmt.Println("请输入任务的个数:")
    	fmt.Scanln(&n)
    	fmt.Println("请输入每个任务的起始时间和执行时间")
    	if Init() {
    		t1 := time.Now()
    		//
    		total_time, average_time = FCFS()
    		fmt.Println("FCFS总时间是:", total_time)
    		fmt.Println("FCFS平均周转时间是:", average_time)
    		total_time, average_time = SJF()
    		fmt.Println("SJF总时间是:", total_time)
    		fmt.Println("SJF平均周转时间是:", average_time)
    		//
    		elapsed := time.Since(t1)
    		fmt.Println("运行时间: ", elapsed)
    	} else {
    		fmt.Println("你输入的数据存在错误\a")
    	}
    }
    


    展开全文
  • 教育资料 xx大学 操作系统 实验报告 姓名 学号 班级 实验日期 实验名称先来先服务FCFS和短作业优先SJF进程调度算法 实验一 先来先服务FCFS和短作业优先SJF进程调度算法 1. 实验目的 通过这次实验理解FCFS和SJF进程...
  • 实现FCFS和SJF调度算法,实验环境为VS2017 图解 SJFFCFS: 源程序 #include <iostream> #include <string.h> using namespace std; typedef struct node{ char name[4]; float reachTime; ...

    实验原理

    实现FCFS和SJF调度算法,实验环境为VS2017

    图解

    SJF:
    SJF
    FCFS:
    FCFS

    源程序

    #include <iostream>
    #include <string.h>
    using namespace std;
    typedef struct node{
    	char name[4];
    	float reachTime;
    	float serverTime;
    	float startTime;
    	float finishTime;
    	float crylingTime;
    	float authorizedCrylingTime;
    }* Process,Nodes;
    
    void FCFS(Process pro);
    void SJF(Process pro);
    
    void FCFS(Process pro){
    	float avgtime = 0;
    	float avgatime = 0;
    	// 计算完成时间
    	pro[0].finishTime = pro[0].reachTime + pro[0].serverTime;
    	for (int i = 1; i < 5; i++){
    		pro[i].finishTime = pro[i - 1].finishTime + pro[i].serverTime;
    	}
    	// 计算周转时间、带权周转时间
    	for (int i = 0; i < 5; i++){
    		pro[i].crylingTime = pro[i].finishTime - pro[i].reachTime;
    		avgtime = avgtime + pro[i].crylingTime;
    		pro[i].authorizedCrylingTime = pro[i].crylingTime / pro[i].serverTime;
    		avgatime = avgatime + pro[i].authorizedCrylingTime;
    	}
    	// 输出
    	for (int j = 0; j < 5; j++){
    		cout << "进程" << pro[j].name << "的完成时间:" << pro[j].finishTime << endl;
    		cout << "进程" << pro[j].name << "的周转时间:" << pro[j].crylingTime << endl;
    		cout << "进程" << pro[j].name << "的带权周转时间:" << pro[j].authorizedCrylingTime << endl;
    	}
    	cout << "平均周转时间:" << avgtime/5;
    	cout << "平均带权周转时间:" << avgatime/5;
    }
    
    void SJF(Process pro){
    	float avgtime = 0;
    	float avgatime = 0;
    	int flag[5] = { 0,1,2,3,4 };   // 设置执行顺序
    	for (int i = 1; i < 5; i++)
    		for (int j = i+1; j < 5; j++)
    		if (pro[flag[i]].serverTime > pro[flag[j]].serverTime){
    			int t = flag[i];
    			flag[i] = j;
    			flag[j] = flag[j];
    		}
    	flag[0] = 0;
    	flag[1] = 3;
    	flag[2] = 1;
    	flag[3] = 4;
    	flag[4] = 2;
    	// 计算完成时间
    	pro[0].finishTime = pro[0].reachTime + pro[0].serverTime;
    	for (int i = 1; i < 5; i++){
    		pro[flag[i]].finishTime = pro[flag[i - 1]].finishTime + pro[flag[i]].serverTime;
    	}
    	// 计算周转时间、带权周转时间
    	for (int i = 0; i < 5; i++){
    		pro[flag[i]].crylingTime = pro[flag[i]].finishTime - pro[flag[i]].reachTime;
    		avgtime = avgtime + pro[flag[i]].crylingTime;
    		pro[flag[i]].authorizedCrylingTime = pro[flag[i]].crylingTime / pro[flag[i]].serverTime;
    		avgatime = avgatime + pro[flag[i]].authorizedCrylingTime;
    	}
    
    	// 输出
    	for (int j = 0; j < 5; j++){
    		cout << "进程" << pro[j].name << "的完成时间:" << pro[j].finishTime << endl;
    		cout << "进程" << pro[j].name << "的周转时间:" << pro[j].crylingTime << endl;
    		cout << "进程" << pro[j].name << "的带权周转时间:" << pro[j].authorizedCrylingTime << endl;
    	}
    	cout << "平均周转时间:" << avgtime/5;
    	cout << "平均带权周转时间:" << avgatime/5;
    }
    int main(){
    	Nodes pro[5];
    	pro[0] = { "A", 0, 4};
    	pro[1] = { "B", 1, 3};
    	pro[2] = { "C", 2, 5};
    	pro[3] = { "D", 3, 2};
    	pro[4] = { "E", 4, 4};
    
    	int choose;
    	cin >> choose;
    	if (choose == 1)
    		FCFS(pro);
    	else if (choose == 2)
    		SJF(pro);
    	else
    		cout << "Please input number between 1 or 2" << endl;
    	return 0;
    }
    

    输出结果

    SJF:
    在这里插入图片描述
    FCFS:
    在这里插入图片描述

    展开全文
  • 当明显长作业出现时,FCFS和SJF的平均周转平均带权周转时间相差很大 三、分析 在这个实验中,我使用到了结构体队列的方法来进行相应的操作,只需要首先先将作业的结构体定义出,同时再将其存入队列中,通过对...
  • FCFS和SJF进程调度算法

    2013-05-29 11:20:33
    设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统,它们需要的服务时间分别为S1, … ,Sn。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度,计算...
  • 先来先服务短作业优先
  • FCFS和SJF算法

    2020-09-16 17:50:35
    void FCFS() { cout<<"\n=========================FCFS调度算法=========================\n"; for(int i=0;inowTime) nowTime=arrivalTime[i]; nowTime+=serviceTime[i]; finishTime[i]=nowTime; } for(int i=0;...
  • 先来先服务(FCFS最短作业优先(SJF)调度 此代码是非抢占式的 这些算法是非抢占式或抢占式的。 非抢占式算法的设计使进程一旦进入运行状态,就无法抢占它,直到它完成其分配的时间为止,而抢占式调度基于优先级...
  • 模拟实现FCFS/SJF调度。 设置作业体:作业名,作业的到达时间,服务时间,作业状态(W——等待,R——运行,F——完成),作业间的链接指针; 作业初始化:由用户输入作业名、服务时间、到达时间进行初始化,同时,...
  • FCFS和SJF代码实现

    千次阅读 2018-07-09 21:19:59
    //分别定义所需时间到达时间 cout 请输入作业的个数:" ; cin >> num; if(num ){ cout 输入非法,请重新输入!" ; } jobnum = num; for(int i = 0;i> need >> arrive; job[i].name = i; job[i].requesttime = need...
  • c语言编写FCFS和SJF

    千次阅读 2018-05-11 10:43:22
    void inputSend()//输入提交时间运行时间 { printf("请输入到达时间:"); for (int i = 0; i ; i++) { scanf("%lf", &send[i]); } printf("请输入服务时间:"); for (int i = 0; i ; i++) { scanf("%lf...
  • 计算机操作系统的调度算法。是txt文本格式的,经编译可用。
  • 先来先服务FCFS和短作业优先SJF进程调度 转自:https://blog.csdn.net/qq_34374664/article/details/73231072 一、概念介绍案例解析 FCFS调度算法 先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既...
  • FCFS和SJF进程调度算法的实现

    千次阅读 2017-04-14 21:42:54
    先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为...
  • FCFS(First-come first-served)先来先服务调度算法 ​​​​​​​核心思想:FCFS算法是指进程调度时是从就绪的进程队列中选择一个最先进入该队列的... SJF(Short Job First)短作业优先调度算法 核心思...
  • FCFS实现较简单: 1.按照时间先后到达顺序,进行进程对列的构造 2.有的时候一个进程处理结束但是后一个进程还未到,则后一个进程的完成时间=进程到达时间+进程服务时间 SJF实现有许多细节要注意:终于有用到for.....
  • Java简单实现进程调度算法 FCFS和SJF

    万次阅读 多人点赞 2017-05-18 11:14:07
    System.out.println("请选择进程调度算法,1:FCFS 2:SJF 其他键:quit"); int select=in.nextInt(); if(select==1){ System.out.println("----------------您选择了FCFS-------------------"); ...
  • 1. 先来先服务(FCFS)调度算法 2.先来先服务(FCFS)算法特点 3. 先来先服务(FCFS)算法的表现与进程到达顺序有关 4. 短作业优先调度算法 5. 非抢占式SJF示例 6. 抢占式SJF示例 7. ...
  • 文章目录FCFSSJF、HRRN调度算法知识总览图先来先服务(FCFS,First Come First Serve)短作业优先(SJF,Shortest Job First)对FCFS和SJF两种算法的思考高响应比优先算法(HRRN,Highest Response Ratio Next) FCFSSJF...
  • 作业调度三种算法FCFSSJF,HRN作业调度三种算法FCFSSJF,HRN作业调度三种算法FCFSSJF,HRN

空空如也

空空如也

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

fcfs和sjf