精华内容
下载资源
问答
  • 操作系统FCFS算法

    2009-10-17 20:41:32
    操作系统的调度算法中的先来先服务算法FCFS,自己写的,恩,反正运行还好啦
  • 操作系统 fcfs pta(Java)版 package pta; import java.util.Arrays; import java.util.Scanner; public class fcfs{ public static void main(String[] args) { int i; //循环变量 int j; //循环变量 ...

     操作系统 fcfs pta(Java)版

    package pta;
    import java.util.Arrays;
    import java.util.Scanner;
    public class fcfs{
    	public static void main(String[] args) {
    		int i;     //循环变量
    		int j;     //循环变量
    		float b;   //b用来交换到达时间,
    		float c;   //c用来交换服务时间
    		String a;  //a用来交换作业名
    		//System.out.println("请输入作业数量:");
    		Scanner writer = new Scanner(System.in);
    		int numb = writer.nextInt();               		//numb记录作业数量
    		float[] finishTime = new float[numb];   		//finishTime记录完成时间
    		float[] turnAroundTime =new float[numb]; 		//turnAroundTime记录周转时间
    		float[] daiTime=new float[numb];				//daiTime记录带权周转时间
    		String[] workName = new String[numb];       	//workName记录作业名
    		float[] reachTime= new float[numb];             //reachTime记录作业到达时间
    		float[] serviceTime= new float[numb];           //serviceTime记录作业服务时间
    		//System.out.println("请输入作业名称:");
    		for(i=0;i<numb;i++) {           //输入作业名
    			workName[i]=writer.next();
    		}
    		//System.out.println("请输入作业到达时间:");
    		for(i=0;i<numb;i++) {          //输入作业到达时间
    			reachTime[i] =  writer.nextFloat();
    		}
    		//System.out.println("请输入作业服务时间:");
    		for(i=0;i<numb;i++) {          //输入作业服务时间
    			serviceTime[i] = writer.nextFloat();
    		}
    		//System.out.println("完成输入!");
    		for(j=0;j<numb-1;j++) {                          //通过比较到达时间来确定服务顺序
    			for(i=j+1;i<numb;i++) {
    				if(reachTime[i]<reachTime[j]) {
    					b=reachTime[i];//交换到达时间
    					reachTime[i]=reachTime[j];
    					reachTime[j]=b;
    					a=workName[i];//交换作业名字
    					workName[i]=workName[j];
    					workName[j]=a;
    					c=serviceTime[i];//交换作业服务时间
    					serviceTime[i]=serviceTime[j];
    					serviceTime[j]=c;	
    				}
    			}
    		}
    //		for(i=0;i<numb;i++) {
    //			System.out.printf("%d",serviceTime[i]);
    //			System.out.printf("%s",workName[i]);
    //			System.out.printf("%d ",reachTime[i]);
    //		}
    		for(i=0;i<numb;i++) { 						//计算过程
    			if(i==0) {
    			    finishTime[i]=reachTime[i]+serviceTime[i];
    			}
    			else {
    				if(finishTime[i-1]<reachTime[i]){
    					finishTime[i]=reachTime[i]+serviceTime[i];
    				}
    				else {
    					finishTime[i]=finishTime[i-1]+serviceTime[i];
    				}
    			}    
    			turnAroundTime[i]=finishTime[i]-reachTime[i];
    			daiTime[i]=turnAroundTime[i]/serviceTime[i];
    		}
    		System.out.printf("作 业 名:");			//输出作业名
    		for(i=0;i<numb;i++) { 
    			if(i<numb-1) {
    				System.out.printf("%s ",workName[i]);
    			}
    			else {
    				System.out.printf("%s",workName[i]);
    			}
    		}
    		System.out.printf("\n到达时间:");		//输出到达时间
    		for(i=0;i<numb;i++) { 
    			if(i<numb-1){
    				System.out.printf("%.0f ",reachTime[i]);
    			}
    			else {
    				System.out.printf("%.0f",reachTime[i]);
    			}
    		}
    		System.out.printf("\n服务时间:");		//输出服务时间
    		for(i=0;i<numb;i++) { 
    			if(i<numb-1) {
    				System.out.printf("%.0f ",serviceTime[i]);
    			}
    			else {
    				System.out.printf("%.0f",serviceTime[i]);
    			}
    		}
    		System.out.printf("\n完成时间:");		//输出完成时间
    		for(i=0;i<numb;i++) {   
    			if(i<numb-1) {
    				System.out.printf("%.0f ",finishTime[i]);
    			}
    			else {
    				System.out.printf("%.0f",finishTime[i]);
    			}
    		}
    		System.out.printf("\n周转时间:");		//输出周转时间
    		for(i=0;i<numb;i++) {   
    			if(i<numb-1) {
    				System.out.printf("%.0f ",turnAroundTime[i]);
    			}
    			else {
    				System.out.printf("%.0f",turnAroundTime[i]);
    			}
    		}
    		System.out.printf("\n带权周转时间:");	//输出带权周转时间
    		for(i=0;i<numb;i++) {   
    			if(i<numb-1) {
    				System.out.printf("%.2f ",daiTime[i]);
    			}
    			else {
    				System.out.printf("%.2f",daiTime[i]);
    			}
    		}
    	}
    }
    

     

    展开全文
  • cout运行FCFS"; cout退出"; cout请输入:"; } void Input() { for(int b=0;b;b++) { cout作业号(0~2):"; cin>>jobline[b].Id; cout到达时间:"; cin>>jobline[b].Arrtime; cout运行时间:"; cin>>jobline[b...
  • 某多道程序系统采用可变分区...采用静态方式分配外部设备,且不能移动内存中的作业,进程调度采用 FCFS 算法,忽略用户作业 I/O 操作时间。现有作业序列如下: 作业号 进入时间 运行时间(min) 内存需求(KB) 磁带机(台)
  • 操作系统 FCFS先到先服务调度算法

    千次阅读 2018-04-26 20:49:39
    void FCFS();//先到先服务调度算法 void SJF();//短进程优先算法 void printProc();//输出进程的计算结果 struct process_type //进程结构 { int pid; int ArrivalTime;//到达时间 int ServiceTime;//服务时间 ...
    //cpp文件
    
    
    #include "stdafx.h"
    
    void FCFS();//先到先服务调度算法
    void  SJF();//短进程优先算法
    void printProc();//输出进程的计算结果
    
    struct process_type //进程结构
    {
    	int pid;
    	int ArrivalTime;//到达时间
    	int ServiceTime;//服务时间
    	int StartTime;//开始时间
    	int FinishTime;//完成时间
    	int RoundTime;//周转时间
    	double WeightRoundTime;//带权周转时间   
    };
    
    struct process_type proc[20];//申请20个进程控制块,内存中进程数最大值为20
    int PNum, NowTime;//PNum表示进程数,NowTime表示当前的时刻
    
    int SumRT = 0; //总周转时间
    double SumWRT = 0; //总带权周转时间
    int AverageRT = 0; //平均周转时间   
    double AverageWRT = 0;//平均带权周转时间
    
    void   main()
    {
    	int i, n;
    	char a;
    	n = 1;
    
    	cout << "请输入进程个数:";
    	cin >> PNum;
    	for (i = 0;i<PNum;i++)
    	{
    		cout << "请输入第" << i + 1 << "个进程的pid,到达时间和服务时间:" << endl;
    		cin >> proc[i].pid;
    		cin >> proc[i].ArrivalTime;
    		cin >> proc[i].ServiceTime;
    	}
    
    	while (n == 1)
    	{
    		cout << "\n********************************************";
    		cout << "\n*               CPU调度演示系统            *";
    		cout << "\n********************************************";
    		cout << "\n           1.FCFS        2.SJF        3.退出";
    		cout << "\n********************************************";
    		cout << "\n请选择(~)";
    		cin >> a;
    
    		//		a=getchar();
    		switch (a)
    		{
    		case'1':
    			FCFS();
    			printProc();
    			break;
    		case'2':
    			SJF();
    			printProc();
    			break;
    		case'3':
    			exit(0);
    		default:
    			n = 0;
    		}
    	}
    }
    
    void printProc()//输出进程的计算结果
    {
    	cout << endl << "进程pid\t到达时间\t服务时间\t周转时间\t带权周转时间\n";//逐个输出每一个进程的相关数据
    
    	for (int i = 0;i<PNum;i++)
    	{
    		cout << endl << proc[i].pid << "\t" << proc[i].ArrivalTime << "\t\t" << proc[i].ServiceTime << "\t\t" << proc[i].RoundTime << "\t\t" << proc[i].WeightRoundTime;
    		SumRT += proc[i].RoundTime;
    		SumWRT += proc[i].WeightRoundTime;
    	}
    	/*计算平均周转时间*/
    	AverageRT = SumRT / PNum;
    	/*计算平均带权周转时间*/
    	AverageWRT = SumWRT / PNum;
    	cout << "\n平均周转时间:" << AverageRT << "\t" << "\t平均带权周转时间:" << AverageWRT << endl;//输出平均周转时间和平均带权周转时间
    }
    
    void FCFS()
    {
    	int i, j;
    	for (i = 0;i<PNum;i++)//按进程到达时间的先后排序
    	{                                  
    		for (j = 0;j<PNum - i - 1;j++)
    		{
    			if (proc[j].ArrivalTime>proc[j + 1].ArrivalTime)
    			{
    				/*	  填写代码   */
    				int a = proc[j + 1].ArrivalTime;
    				int b = proc[j + 1].RoundTime;
    				int c = proc[j + 1].pid;
    
    				proc[j + 1].ArrivalTime =  proc[j].ArrivalTime;
    				proc[j + 1].RoundTime   =  proc[j].RoundTime;
    				proc[j + 1].pid         =  proc[j].pid;
    
    				proc[j].ArrivalTime =  a;
    				proc[j].RoundTime =  b;
    				proc[j].pid =  c;
    
    
    			}
    		}
    	}
    	
    
    
    
    	for (i = 0;i<PNum;i++)
    	{
    		if (i == 0)
    		{
    			/*计算开始时间*/
    			proc[i].StartTime = 0;
    
    			/*计算结束时间*/
    			proc[i].FinishTime = proc[i].StartTime + proc[i].ServiceTime;
    		}
    		else
    		{
    			if (proc[i].ArrivalTime<proc[i - 1].FinishTime)
    			{
    				/*计算结束时间*/
    				proc[i].StartTime = proc[i - 1].FinishTime;//开始时间等于上一个进程的结束时间
    				proc[i].FinishTime = proc[i].StartTime + proc[i].ServiceTime;//结束时间等于开始时间加上服务时间
    
    			}
    			else
    			{
    				/*计算结束时间*/
    				proc[i].StartTime = proc[i].ArrivalTime;//如果在前一个进程结束之后到达,则开始时间等于到到达时间
    				proc[i].FinishTime = proc[i].StartTime + proc[i].ServiceTime;//结束时间等于开始时间加上服务时间
    			}
    		}
    
    
    
    	
    
    		printf("进程%d从%d开始,在%d时刻结束\n", proc[i].pid, proc[i].StartTime, proc[i].FinishTime);
    
    		proc[i].RoundTime = proc[i].FinishTime - proc[i].ArrivalTime;//周转时间
    		proc[i].WeightRoundTime = proc[i].RoundTime / proc[i].ServiceTime;//带权周转时间
    
    		proc[i + 1].StartTime = proc[i].FinishTime;
    	}
    	//	printProc();
    }
    
    void SJF()
    {
    
    }
    
    
    //头文件
    // stdafx.h : 标准系统包含文件的包含文件,
    // 或是经常使用但不常更改的
    // 特定于项目的包含文件
    //
    
    #pragma once
    
    #include "targetver.h"
    
    #include <stdio.h>
    #include <tchar.h>
    
    
    
    // TODO:  在此处引用程序需要的其他头文件
    
    #include "stdafx.h"
    #include <iostream>
    #include "conio.h"
    #include "stdio.h"
    #include "stdlib.h"
    
    using namespace std;
    
    
    
    


    展开全文
  • 模拟实现FCFS/SJF调度。 设置作业体:作业名,作业的到达时间,服务时间,作业状态(W——等待,R——运行,F——完成),作业间的链接指针; 作业初始化:由用户输入作业名、服务时间、到达时间进行初始化,同时,...

    实验内容

    模拟实现FCFS/SJF调度。

    设置作业体:作业名,作业的到达时间,服务时间,作业状态(W——等待,R——运行,F——完成),作业间的链接指针;

    作业初始化:由用户输入作业名、服务时间、到达时间进行初始化,同时,初始化作业的状态为W。

    显示函数:在作业调度前、调度中和调度后进行显示。

    排序函数:对等待状态的作业按照调度算法排序(不同的调度算法排序方式不同),注意考虑到达时间。

    调度函数:每次从等待队列队首调度已到达的适合的作业执行,状态变化。当服务结束时,状态变为F。

    删除函数:撤销状态为F的作业。

    实验要求

    (1)测试数据可以随即输入或从文件中读入;

    (2)必须要考虑到作业的到达时间;

    (3)最终能够计算每一个作业的周转时间、带权周转时间。

    pcb=[]
    n=int(input("请输入你的进程数:"))
    def inPcb():
        i=0
        while(i<n):
            print("********************************************") 
            pName = input("请输入第 %d 个进程名:" % (i+1))
            print("请输入到达时间和服务时间:",end="")
            arriveTime,serviceTime=map(int,input().split())
            pcb.append([pName,arriveTime,serviceTime,0,0,0,0,])
            i=i+1
    #文件输入数据
    def fileinPcb():
        filename=input("请输入文件名:")
        infile=open(filename,"r")
        data=infile.read()
        print("文件内容:")
        print(data)
        data=data.split()
        k=0
        while(k<n):
            pcb.append([0,0,0,0,0,0,0,])
            k=k+1
        s=0
        for i in range(n):
            for j in range(3):
                pcb[i][j]=data[s]
                s=s+1
    #先来先调度算法
    def FCFS():
        #对列表按照到达时间进行升序排序  x:x[1]为依照到达时间进行排序
        pcb.sort(key = lambda x:x[1], reverse = False )
        #计算开始、完成时间
        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])
            elif(i > 0 and  int(pcb[i - 1][4]) < int(pcb[i][1])):
                startTime = int(pcb[i][1])
                pcb[i][3] = startTime
                pcb[i][4] = startTime + int(pcb[i][2])
            else:
                startTime = int(pcb[i - 1][4])
                pcb[i][3] = startTime
                pcb[i][4] = startTime + int(pcb[i][2])
            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 += 1
        #计算平均周转时间和平均带权周转时间
        SzzTime = 0
        SdqzzTime = 0
        for i in range(n):
            SzzTime = float(SzzTime + float(pcb[i][5]))
            SdqzzTime = float(SdqzzTime + float(pcb[i][6]))
        AzzTime = float(SzzTime / n)
        AdqzzTime = float(SdqzzTime / n)
        #输出结果,按照开始时间进行排序
        pcb.sort(key = lambda x:x[3], reverse = False)
        print("FCFS运行结果:")
        print("进程   到达时间  服务时间 开始时间  完成时间  周转时间  带权周转时间")
        for i  in range(n):
            print("%s%10.1f%10.1f%10.1f%10.1f%10.1f%10.2f"%(pcb[i][0],float(pcb[i][1]),float(pcb[i][2]),float(pcb[i][3]),float(pcb[i][4]),float(pcb[i][5]),float(pcb[i][6])))
            i += 1
        print("本次调度的平均周转时间为: %.2f" % float(AzzTime))
        print("本次调度的平均带权周转时间为: %.2f" % float(AdqzzTime))
    #短作业优先调度算法
    def SJF():
        sjf_pcb = pcb
        i = 1
        k = 0
        # 对列表按照到达时间进行升序排序  x:x[1]为依照到达时间进行排序
        sjf_pcb.sort(key = lambda x: x[1], reverse = False)
        #定义列表的第一项内容
        startTime0 = int(sjf_pcb[0][1])
        pcb[0][3] = startTime0
        pcb[0][4] = startTime0 + int(sjf_pcb[0][2])
        sjf_pcb[0][5] = int(sjf_pcb[0][4]) - int(sjf_pcb[0][1])
        sjf_pcb[0][6] = float(sjf_pcb[0][5]) / int(sjf_pcb[0][2])
        # 对后背队列按照服务时间排序
        temp_pcb = sjf_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
        #进行计算 用K值避免对最后一个进程的两次计算
        while(i < n):
            h = 1
            # 比较到达时间和前一者的完成时间,判断是否需要进行重新排序
            while(int(sjf_pcb[i][1]) >= int(sjf_pcb[i - 1][4])):
                if(i == n-1):    #当最后一个进程的到达时间大于前一个进程的完成时间
                    startTime = sjf_pcb[i][1]
                    sjf_pcb[i][3] = startTime
                    sjf_pcb[i][4] = startTime + int(sjf_pcb[i][2])
                    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])
                    k = 1      #设置参数对比,避免一重循环之后再对末尾进程重新计算
                    break
                else:      #对进程顺序进行调换
                    temp_sjf_pcb = sjf_pcb[i]
                    sjf_pcb[i] = sjf_pcb[i + h]
                    sjf_pcb[i + h] = temp_sjf_pcb
                    h += 1
                    #如果后面的所有进程的到达时间都大于第 i 个进程的完成时间
                    #则重新将i之后的进程按照服务时间排序,直接对其进行计算,同时i += 1,直接开始后面的计算              
                    if( h >= n - i - 1):
                        temp_pcb2 = sjf_pcb[i:len(sjf_pcb)]
                        temp_pcb2.sort(key=lambda x: x[1], reverse=False)   # 后续队列重新按照到达时间顺序进行排序
                        sjf_pcb[i:len(sjf_pcb)] = temp_pcb2
                        sjf_pcb[i][3] = int(sjf_pcb[i][1])
                        sjf_pcb[i][4] = int(sjf_pcb[i][1]) + int(sjf_pcb[i][2])
                        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])
                        temp_pcb2 = sjf_pcb[i + 1:len(sjf_pcb)]
                        temp_pcb2.sort(key=lambda x: x[2], reverse=False)  # 重新按照服务时间排序
                        sjf_pcb[i + 1:len(sjf_pcb)] = temp_pcb2
                        h = 1
                        i += 1
                    else:
                     continue
            if(k == 1):
                break
            else:
                startTime = sjf_pcb[i - 1][4]
                sjf_pcb[i][3] = startTime
                sjf_pcb[i][4] = startTime + int(sjf_pcb[i][2])
                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 += 1
        # 计算平均周转时间和平均带权周转时间
        SzzTime = 0
        SdqzzTime = 0
        for i in range(n):
            SzzTime = float(SzzTime + float(pcb[i][5]))
            SdqzzTime = float(SdqzzTime + float(pcb[i][6]))
            AzzTime = float(SzzTime / n)
            AdqzzTime = float(SdqzzTime / n)
        # 输出结果,按照开始时间进行排序
        sjf_pcb.sort(key=lambda x: x[3], reverse=False)
        print("SJF运行结果:")
        print("进程   到达时间  服务时间 开始时间  完成时间  周转时间  带权周转时间")
        for i  in range(n):
            print("%s%10.1f%10.1f%10.1f%10.1f%10.1f%10.2f"%(pcb[i][0],float(pcb[i][1]),float(pcb[i][2]),float(pcb[i][3]),float(pcb[i][4]),float(pcb[i][5]),float(pcb[i][6])))
            i += 1
        print("本次调度的平均周转时间为: %.2f" % float(AzzTime))
        print("本次调度的平均带权周转时间为: %.2f" % float(AdqzzTime))
     if __name__ == '__main__':
        print("提供两种数据输入方式:1.终端输入  2.文件输入")
        option1=int(input("请选择输入方式:"))
        if(option1==1):
            inPcb()
        elif(option1==2):
            fileinPcb()
        else:
            print("输入错误,请关闭,重新运行程序")
        print()
        print("算法一:先来先服务算法FCFS")
        print("算法二:短作业优先算法SJF")
        m = 1
        while(m == 1):
            option = int(input("请输入你要选择的算法(输入1,2进行选择,其他退出):"))
            if(option == 1):
                FCFS()
            elif(option == 2):
                SJF()
            else:
                print("退出计算")
                m = 0
    
    
        
    
    
    展开全文
  • 基于VS2010,输入程序等数据,然后模拟调度。
  • 相比之前的版本,增加了随机生成数据的功能。
  • 操作系统FCFS,SJF进程调度(C++)

    千次阅读 2015-10-15 16:50:09
    采用静态方式分配外部设备,且不能移动内存中的作业,进程调度采用FCFS算法,忽略用户作业I/O操作时间。现有作业序列如下: 作业号进入时间运行时间(min)内存需求(KB)磁带机(台) A 8:30 40 30 3 B 8:5

        今天整理文件时发现了上学期做的大作业,记录一下.

    1.需求分析

    某多道程序系统采用可变分区存储管理,供用户使用的内存空间为200KB,磁带机5台。采用静态方式分配外部设备,且不能移动内存中的作业,进程调度采用FCFS算法,忽略用户作业I/O操作时间。现有作业序列如下:

    作业号进入时间运行时间(min)内存需求(KB)磁带机()

    A 8:30 40 30 3

    B 8:50 25 120 1

    C 9:00 35 100 2

    D 9:05 20 20 3

    E 9:10 10 60 1

    求:(1FCFS算法选中作业装入内存时间、开始执行时间、执行结束时间、执行的次序、作业平均周转时间、内存分配情况;

    2SJF算法选中作业装入内存时间、开始执行时间、执行结束时间、执行的次序、作业平均周转时间、内存分配情况

    2.详细说明:
    1 .先来先服务算法。说明:
    ( 1 ) 8 : 30 作业A 到达并投入运行。注意它所占用的资源。
    ( 2 ) 8 : 50 作业B 到达,资源满足进主存就绪队列等CPu 。
    ( 3 ) 9 : 00 作业C 到达,主存和磁带机均不够,进后备作业队列等待。
    ( 4 ) 9 : 05 作业D 到达,磁带机不够,进后备作业队列等待。后备作业队列有C 、D 。
    ( 5 ) 9 : 10 作业A 运行结束,归还资源磁带,但注意主存不能移动(即不能紧缩)。作业B 投入运行。作业C 仍因主存不够而等在后备队列。这时作业E 也到达了,。也由于主存不够进入后备作业队列。此时作业D 因资源满足(主存磁带均满足),进主存就绪队列等待。后备作业队列还有C 、E 。
    ( 6 ) 9 : 35 作业B 运行结束,作业D 投入运行。这时作业C 因资源满足而调入主存进就绪队列等CPU 。而作业E 因磁带机不够继续在后备作业队列等待。
    ( 7 ) 9 : 55 作业D 运行结束,作业C 投入运行。这时作业E 因资源满足而调入主存进就绪队列等CPU 。
    ( 8 ) 10 : 30 作业C 运行结束,、作业E 投入运行。
    ( 9 ) 10 : 40 作业E 运行结束。
     
    2 .短作业优先算法。说明:
    ( 1 ) 8 : 30 作业A 到达并投入运行。注意它所占用的资源。  
    ( 2 ) 8 : 50 作业B 到达,资源满足进主存就绪队列等CPU 。  
    ( 3 ) 9 : 00 作业C 到达,主存和磁带机均不够,进后备作业队列等待。  
    ( 4 ) 9 : 05 作业D 到达,磁带机不够,进后备作业队列等待。后备作业队列有C 、D .  
    ( 5 ) 9 : 10 作业A 运行结束,归还资源磁带,但注意主存不能移动(即不能紧缩)。作业B 投入运行。作业C 仍因主存不够而等在后备队列。这时作业E 也到达了,虽然该作业最短,也由于主存不够进入后备作业队列.此时作业D 因资源满足(主存磁带均满脚,进主存就绪队列等待。后备作业队列还有C 、E 。  
    ( 6 ) 9 : 35 作业B 运行结束,作业D 投入运行。这时作业C 和E 资源均满足,但按SJF 应把作业E 调入主存进就绪队列等CPU 。而作业C 因磁带机不够继续在后备作业队列等待。  
    ( 7 ) 9 : 55 作业D 运行结束,作业C 调入主存进就绪队列等CPU .
    ( 8 ) 10 : 05 作业E 运行结束,作业C 投入运行.  
    ( 9 ) 10 : 40 作业C 运行结束。

    3.概要设计

    2.1内存分配

    1. 要维护两条链表,已分配内存链,未分配内存链。

    2. 已分配内存链里的节点为进程名,内存开始地址和结束地址。

    3. 未分配内存链里的节点为内存开始地址和结束地址且初始化的时候首节点为(0200)。

    4. 当有内存变动的时候同时修改两条链表。

    2.2设备分配

    2.3就绪队列

    1. 已分配内存的进程且设备足够的时候进入就绪队列

    2. 依次释放就绪队列中的进程

    2.4后备队列

    1. FCFS算法,后备队列按到达顺序申请内存和设备

    2. SJF算法,后备队列按短作业优先的顺序申请内存和设备

    2.5数据的录入

    1. 进程的到达时间为整型变量

    2. 后续的相关计算都以第一个进程的到达时间为基准进行计算

    2.6进程调度

    采用FCSFS算法调度

    2.7作业调度算法

    1. FCFS算法

    2. SJF算法

    2.8菜单

    *******************任务2*进程调度采用FCFS********************

    1-输入作业

    2-选择作业调度算法(默认为FCFS)

    3-显示答案

    4-清屏

    5-退出

    *******************任务2*进程调度采用FCFS********************


    完整代码  http://download.csdn.net/detail/a__yes/9184021

    4. 实现与测试
    4.1 进程进内存
    在内存满足的情况下,在未分配链中切出一块内存,直接将切下的内存加到已分配内存链尾。
    bool in(string No, int p_mem)
    	{
    		unusedlist *p, *q;				//工作指针
    		bool sign=false;					//内存改变标志
    		int rem;							//记录要分配内存的起始地址
    		p = unusedhead;					
    		while (p->next)
    		{
    			
    			if (p->next->end - p->next->start >p_mem)		//空闲分区大于请求大小
    			{
    				rem = p->next->start;
    				p->next->start = p->next->start + p_mem;		//修改未分配链
    				sign = true;
    				break;
    			}
    			else if (p->next->end - p->next->start == p_mem)	//空闲分区等于请求大小
    			{
    				rem = p->next->start;
    				q = p->next;
    				p->next = q->next;
    				delete q;
    				sign = true;
    				break;
    			}
    			p = p->next;
    		}
    
    		usedlist *x;
    		x = usedhead;
    		if (sign)								//内存改变时才添加已分配节点
    		{
    			usedlist *z = new usedlist();
    			z->No = No;
    			z->start = rem;										//添加已分配节点
    			z->end = rem + p_mem;
    			while (x->next)
    			{
    				x = x->next;
    			}
    			z->next = x->next;
    			x->next = z;
    			return true;
    		}
    		return false;
    }
    4.2 进程释放内存
    将已分配链该No的节点删除,并将其加到为分配内存链中。
    void del(string No)						//已分配内存
    	{
    		usedlist *p,*q,*o;				//加o,因为要初始化q
    		p= usedhead;
    		q = new usedlist();				//用来保存要释放的进程节点
    		while (p->next)
    		{
    			if (p->next->No == No)			//根据进程名来删除节点
    			{
    				o = p->next;
    				q->start = o->start;
    				q->end = o->end;
    				q->No = o->No;
    				q->next = o->next;
    				
    				p->next = o->next;
    				delete o;
    				break;
    			}
    			p = p->next;
    		}
    
    		unusedlist *x,*y,*w;
    		x = unusedhead;					//未分配列表
    		while (x->next)
    		{									//q为已分配链里删除的节点
    			if (unusedhead->next == NULL)							//只剩头节点
    			{
    				unusedlist *z = new unusedlist();
    				z->start = q->start;
    				z->end = q->end;
    
    				z->next = unusedhead->next;
    				unusedhead->next = z;
    				break;
    			}
    if (x->next->end < q->start)		//q的起始地址大于前面节点的结束地址
    			{
    				if (x->next->next)					//q前后有节点
    				{
    					if (x->next->next->start  >  q->end)
    					{
    						unusedlist *z = new unusedlist();
    						z->start = q->start;
    						z->end = q->end;
    
    						y = x->next;
    						z->next = y->next;
    						y->next = z;
    						break;
    					}
    					else if (x->next->next->start == q->end)
    					{
    						y = x->next;
    						y->next->start = q->start;
    						break;
    					}
    				}
    				else 									//q前有节点,后无节点
    				{ 
    					unusedlist *z = new unusedlist();
    					z->start = q->start;
    					z->end = q->end;
    
    					y = x->next;
    					z->next = y->next;
    					y->next = z;
    					break;
    				}
    }
    			else if (x->next->end == q->start)				//q前有节点
    			{
    				if (x->next->next)						//q前后有节点
    				{
    					if (x->next->next->start > q->end)
    					{
    						x->next->end = q->end;
    					}
    					else if (x->next->next->start == q->end)
    					{
    						x->next->end = x->next->next->end;
    						y = x->next;
    						w = y->next;
    						y->next = w->next;
    						delete w;
    					}
    				}
    				else									//q前有无节点,后无节点
    				{
    					x->next->end = q->end;
    				}
    				break;
    			}
    			else	                                     //q前无节点
    			{
    				if (x->next->start == q->end)
    				{
    					x->next->start = q->start;
    break;
    				}
    				else
    				{
    					unusedlist *z = new unusedlist();
    					z->start = q->start;
    					z->end = q->end;
    					z->next = unusedhead->next;
    					unusedhead->next = z;
    					break;
    				}
    				
    			}
    			x = x->next;
    		}
    }
    4.3 输出两条链表情况
    void ls()
    	{
    		usedlist *p;
    		p = usedhead;
    		cout << "已分配列表:\n";
    		while (p->next)
    		{
    			cout << "(" <<p->next->No<<","<< p->next->start << "," 
    << p->next->end << ")\t";
    			p = p->next;
    		}
    		
    		unusedlist *q;
    		q = unusedhead;
    		cout << "\n未分配列表:\n";
    		while (q->next)
    		{
    			cout << "(" << q->next->start << ',' << q->next->end << ")\t";
    			q = q->next;
    		}
    		cout << endl;
    }
    4.4	进程进队列
    调用list->in函数进行进队列区分
    void in_mem(int &m_cidai, PCB pcb)
    	{
    		done = true;
    		if (m_cidai >= pcb.p_cidai&&list->in(pcb.No, pcb.p_mem))
    		{										//进就绪队列
    			m_cidai -= pcb.p_cidai;			
    			pcbready[r_count] = pcb;
    			r_count++;							//就绪队列计数
    		}
    		else
    		{
    			pcbback[b_count] = pcb;				//进后备队列
    			b_count++;							//后备队列计数
    		}
    }
    4.4 升序排序
    void sort(PCB *pcb,int num)
    	{
    		for (int i = 1;i<num; i++)
    		{
    			for (int ii = 0; ii < num - i; ii++)
    			{
    				if (pcb[ii].run_time>pcb[ii+1].run_time)
    				{
    					PCB p_pcb = pcb[ii]; pcb[ii] = pcb[ii + 1]; pcb[ii + 1] = p_pcb;
    				}
    			}
    		}
    }
    
    4.5 作业调度
    将第一个进程完成之前到达的作业,进行分别入队。在第一个进程完成之后到下一个进程完成之前到达的进程分别入队,将后备队列的进程在分别入队。以此类推。
    void dispatch(int &m_cidai, int m,string way)
    	{
    		int j=0;							//cpu中就绪队列进程的序号
    		int m_sign=0;						//到达并进队的位置
    		int a=1;							//就绪队列中已计算(其他时间)的 pcb位置
    		
    		r_count = 0;						
    		t = pcb[0].ar_time;
    		pcb[0].sta_time = t;
    		pcb[0].end_time = pcb[0].sta_time + pcb[0].run_time;
    		pcb[0].in_time = t;								//第一个任务可以确定
    		pcb[0].rou_time = pcb[0].end_time - pcb[0].sta_time;
    		pcbready[0] = pcb[0];
    
    		while (j < m)
    		{
    			done = false;
    			cout << "时间:"<<t << endl;
    			if (m_sign<m)
    				cout << "已到达进程尝试进内存.\n";
    			for (int i = m_sign; i < m; i++)
    			{
    				if (pcb[i].ar_time <= t + pcbready[j].run_time||a==r_count&&b_count==0)
    				{							//到达的pcb	或 cpu为空且后备队列为空
    					in_mem(m_cidai, pcb[i]);	
    					m_sign = i + 1;
    				}
    
    			}
    			if (done)						//调用in_mem判断
    				list->ls();
    			for (int i = a; i < r_count; i++)
    			{
    				
    				
    				if (pcbready[i].ar_time>t)
    					pcbready[i].in_time = pcbready[i].ar_time;
    				else
    					pcbready[i].in_time = t;
    				if (pcbready[i].ar_time > pcbready[i - 1].end_time)	//cpu为空
    					pcbready[i].sta_time = pcbready[i].ar_time;
    				else
    					pcbready[i].sta_time = pcbready[i - 1].end_time;
    				pcbready[i].end_time = pcbready[i].sta_time + pcbready[i].run_time;
    				pcbready[i].rou_time = pcbready[i].end_time - pcbready[i].ar_time;
    				a = i + 1;
    			}
    			cout << pcbready[j].No << "执行完,后备队列尝试进内存.\n";
    			list->del(pcbready[j].No);
    			m_cidai += pcbready[j].p_cidai;					//释放内存
    			t = pcbready[j].end_time;	
    			j++;
    
    			
    			int bb_count = b_count;							//需要将b_count置零
    			b_count = 0;
    			for (int i = 0; i < bb_count; i++)
    			{
    				if (way=="sjf")							//SJF算法判断
    					sort(pcbback, bb_count);
    				in_mem(m_cidai, pcbback[i]);
    			}
    			list->ls();
    		}
    }


    展开全文
  • Java 模拟实现操作系统中 进程调度中的先来先服务算法(FCFS) ,源代码注释清晰,操作简单。。。。。
  • 操作系统 实验 FCFS SJF RR MLFS 模拟实现 1000个进程模拟 结果
  • 操作系统中的FCFS算法

    2015-04-15 13:42:49
    操作系统中的FCFS算法,用C语言进行编写,代码简单明了,并且实现了六十进制和百进制之间的转换,易于初学操作系统的人更加了解FCFS算法
  • 本实验要求学生独立地编写一个简单的作业管理程序,其主要部分是作业调度。调度算法可由学生自行选择,这里选用先来先服务FCFS调度算法。
  • FCFS操作系统实验

    2013-06-07 11:49:30
    操作系统 实验 代码 C++
  • 操作系统FCFS调度算法简单实现(c++)

    千次阅读 多人点赞 2019-10-15 19:23:00
    计算机操作系统FCFS调度算法简单实现 由于本人(小白一个)一直以来一直想要写博客,加上最近学习操作系统,为了巩固自己的学习成果已经加深印象,现在决定开始写博客,可以说这是我的第一篇博客。 今天主要...
  • 操作系统实验 SJF算法 FCFS 算法 java实现
  • 操作系统FCFS算法

    千次阅读 2019-07-30 08:55:29
    假定在一个处理机上执行的操作如下: 作业 估计服务时间 各作业到达时间 A 2 0 B 3 3 C 1 4 D 5 6 E 4 5 FCFS算法(First come first served):先来先服务算法:根据...
  • 操作系统-FCFS与FJS算法-作业调度算法
  • 操作系统 作业调度 附加实验结果 1.FCFS 2.SJF 3.HRN
  • 操作系统 作业调度算法实现 包括fcfs和sjp算法的实现。一个程序包括所有的。
  • FCFS(First-come first-served)先来先服务调度算法 ​​​​​​​核心思想:FCFS算法是指进程调度时是从就绪的进程队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行的一种调度算法。 作用...
  • 先来先服务FCFS和短作业优先SJF进程调度 转自:https://blog.csdn.net/qq_34374664/article/details/73231072 一、概念介绍和案例解析 FCFS调度算法 先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既...
  • FCFS算法 操作系统

    2009-11-06 23:41:53
    简单易懂的先来先服务算法 Word格式 c++源码
  • 实验项目名称 作业调度算法 实验目的 加深作业概念的理解 模拟先来先服务 (FCFS)与短作业优先调度算法 (SJF) 实验要求 模拟先来先服务 (FCFS)与短作业优先调度算法 (SJF)运行 实验原理 作业调度算法 1)先来先服务...
  • FCFS算法仿真,计算机操作系统实验的作业,免费下载
  • FCFS实现较简单: 1.按照时间先后到达顺序,进行进程对列的构造 2.有的时候一个进程处理结束但是后一个进程还未到,则后一个进程的完成时间=进程到达时间+进程服务时间 SJF实现有许多细节要注意:终于有用到for.....
  • C语言编写的操作系统实验作业:作业调度算法,包括三种算法FCFS,SJF,HRN
  • 操作系统实验一进程调度 用先来先服务,短进程优先算法模拟系统进程调度

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,848
精华内容 3,139
关键字:

操作系统fcfs