1. 程式人生 > >先來先服務,短作業優先,最高響應比三種演算法下求平均週轉和帶權週轉時間的實現

先來先服務,短作業優先,最高響應比三種演算法下求平均週轉和帶權週轉時間的實現





codear發表於 2006年04月11日 21:20:00 (http://blog.csdn.net/coDear)
#include<iostream.h>
#define N 6
struct time{
    float arriveTime;
    float runTime;
    float finishTime;
    float totalTime;
    float weightTotalTime;
    char name;
};

 void InputTime(time *p)
 {
     int i;//counter
     cout<<"input name & arrive time & run time:"<<endl;
     for(i=0;i<=N-1;i++){
         float temp1,temp2;
         char name;
         cout<<"作業名:"<<endl;
         cin>>name;
         p[i].name=name;
         cout<<"到達時:"<<endl;
         cin>>temp1;
         p[i].arriveTime=temp1;
         cout<<"執行時間:"<<endl;
         cin>>temp2;
         p[i].runTime=temp2;
        
     }
         
 }
 void Print(time *p,float totalTimeSum,float weightTotalTimeSum){

     cout<<"執行次序:"<<endl;
     for(int k=0;k<=N-1;k++)
     {
         cout<<p[k].name<<" ";
        
     }
     cout<<endl;
     cout<<"平均週轉時間:"<<totalTimeSum/N<<endl;
     cout<<"平均帶權週轉時間:"<<weightTotalTimeSum/N<<endl;
}
 void sort(time *p)
 {
     for(int i=0;i<=N-1;i++)
         for(int j=0;j<=i;j++)
             if(p[i].arriveTime<p[j].arriveTime)
             {
                 time temp;
                 temp=p[i];
                 p[i]=p[j];
                 p[j]=temp;
             }
 }

 void deal(time *p,float &totalTimeSum,float &weightTotalTimeSum)
 {
    
              int k;//counter
     for(k=0;k<=N-1;k++)
     {
         if(k==0)
             p[k].finishTime=p[k].arriveTime+p[k].runTime;
         else
             p[k].finishTime=p[k-1].finishTime+p[k].runTime;
     }

     for(k=0;k<=N-1;k++)
     {
     p[k].totalTime=p[k].finishTime-p[k].arriveTime;
     p[k].weightTotalTime=p[k].totalTime/p[k].runTime;
    
        
         totalTimeSum+=p[k].totalTime;
         weightTotalTimeSum+=p[k].weightTotalTime;
     }
 }



 void FCFS(time *p)
 {
     float totalTimeSum=0,weightTotalTimeSum=0;

     sort(p);

     deal(p,totalTimeSum,weightTotalTimeSum);

     cout<<"先來先服務:"<<endl;

Print(p,totalTimeSum,weightTotalTimeSum);

    
 }


void SWF(time *p)
 {
    
     float totalTimeSum=0,weightTotalTimeSum=0;

     sort(p);

        for(int m=0;m<N-1;m++)
        {
        
            if(m==0)
            p[m].finishTime=p[m].arriveTime+p[m].runTime;
            else
                p[m].finishTime=p[m-1].finishTime+p[m].runTime;

            int i=0;
            for(int n=m+1;n<=N-1;n++)
            {
                
                if(p[n].arriveTime<=p[m].finishTime)
                    i++;
            }
            float min=p[m+1].runTime;
            int follow=m+1;
            for(int k=m+1;k<m+i;k++)
            {
                
            if(p[k+1].runTime<min)
            {min=p[k+1].runTime;
            follow=k+1;}
            
            }
            time temp;
            temp=p[m+1];
            p[m+1]=p[follow];
            p[follow]=temp;
        }
        
    

     deal(p,totalTimeSum,weightTotalTimeSum);

     cout<<"短作業優先:"<<endl;


    Print(p,totalTimeSum,weightTotalTimeSum);
}

void TRRF(time *p){
    float totalTimeSum=0,weightTotalTimeSum=0;

     sort(p);

        for(int m=0;m<N-1;m++)
        {
            
            if(m==0)
            p[m].finishTime=p[m].arriveTime+p[m].runTime;
            else
                p[m].finishTime=p[m-1].finishTime+p[m].runTime;

            int i=0;
            for(int n=m+1;n<=N-1;n++)
            {
                
                if(p[n].arriveTime<=p[m].finishTime)
                    i++;
            }
            float max=(p[m].finishTime-p[m+1].arriveTime)/p[m+1].runTime;
            int follow=m+1;
            for(int k=m+1;k<m+i;k++)
            {
                
                if(max<=(p[m].finishTime-p[k+1].arriveTime)/p[k+1].runTime){
            max=(p[m].finishTime-p[k+1].arriveTime)/p[k+1].runTime;
            follow=k+1;
                }
            
            }
            time temp;
            temp=p[m+1];
            p[m+1]=p[follow];
            p[follow]=temp;
        }
        
    

     deal(p,totalTimeSum,weightTotalTimeSum);

     cout<<"最高響應比優先:"<<endl;


    Print(p,totalTimeSum,weightTotalTimeSum);
}
        

void main(){
    
    time a[N];
    InputTime(a);
    time *b=a;time *c=a;
    FCFS(a);
    SWF(b);
    TRRF(c);

}
    
/*
input name & arrive time & run time:
作業名:
a
到達時:
0
執行時間:
6
作業名:
b
到達時:
2
執行時間:
50
作業名:
c
到達時:
5
執行時間:
20
作業名:
d
到達時:
5
執行時間:
10
作業名:
e
到達時:
12
執行時間:
40
作業名:
f
到達時:
15
執行時間:
8
先來先服務:
執行次序:
a b c d e f
平均週轉時間:74.1667
平均帶權週轉時間:5.2425
短作業優先:
執行次序:
a d f c e b
平均週轉時間:44.8333
平均帶權週轉時間:1.6025
最高響應比優先:
執行次序:
a d c f b e
平均週轉時間:48.5
平均帶權週轉時間:2.0275
Press any key to continue
*/ 

相關推薦

服務作業優先最高響應演算法平均週轉週轉時間實現

codear發表於 2006年04月11日 21:20:00 (http://blog.csdn.net/coDear) #include<iostream.h>#define N 6struct time{    float arriveTime;    fl

Java模擬最作業優先時間片輪轉、最高響應程序排程演算法

本次試驗是使用程式來模擬作業系統中程序排程的三種不同的排程策略,分別為最短作業有限、時間片輪轉、最高響應比。 模擬的情況下,程序數為8,程序所需執行時間為隨機產生的整數,單位為1S,預設程序同時到達。 以下是實驗的程式碼: Process.java是測試類,用於生成程序列表

Java實現服務作業優先

1、定義作業類 package com.ghs.job; public class Job { /**作業編號*/ private String jobId; /**執行時間*/ private int runTime;

作業系統:服務FCFS作業優先SJF程序排程演算法

目的:陸續整理近一年的學習收穫                                先來先服務FCFS和短作

【作業系統 】服務FCFS作業優先SJF程序排程演算法

  1.先來先服務FCFS和短作業優先SJF程序排程演算法 2.時間片輪轉RR程序排程演算法 3.預防程序死鎖的銀行家演算法 4.動態分割槽分配演算法 5.虛擬記憶體頁面置換演算法 6.磁碟排程演算法 void FCFS() { /* 1. 找

《作業系統》 服務FCFS作業優先SJF程序排程演算法相關計算及實驗

  為了和FCFS排程演算法進行比較,我們仍利用FCFS演算法中所使用的例項,並改用SJ(P)F演算法重新排程,再進行效能分析。由上圖中的(a)和(b)可以看出,採用SJ(P)F演算法後,不論是平均週轉時間還是平均帶權週轉時間,都有較明顯的改善,尤其是對短作業D,其週轉時間由原來的(用FCFS演算法時)1

服務演算法(FCFS) 作業優先演算法(SJF)

先來先服務演算法(FCFS) FCFS是最簡單的排程演算法,既可以用作作業排程,也可以用作程序排程 這種演算法優先考慮系統中等待時間最長的作業(程序),而不管作業所需執行時間長短, 做法是從後備佇列中選擇幾個最先進入該佇列的作業,將它們調入記憶體,為它們分配資源和建

作業優先排程演算法 服務作業排程演算法(c語言描述)

/*先來先服務排程演算法*/ #include<stdio.h> #define N 10 int Arival[N]={0}; int Go[N]={0}; int Start[N]={0}; int End[N]={0}; int Timer[N]={0};

1】服務FCFS作業優先SJF程序排程演算法

// 作業系統_實驗一.cpp : 定義控制檯應用程式的入口點。 // /* //實驗題目:先來先服務FCFS和短作業優先SJF程序排程演算法 *******概念******* 1. 先來先服務FCFS: 2. 短作業優先SJF: 3. 高階排程:根據某種演算法,在外存中把處於後備佇列中的那些作業調入記憶體,

java_實現服務(FCFS)作業優先演算法(SJF)

  import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.nio.ByteBuffer; import java.ut

作業系統——實驗一(服務演算法作業優先演算法

作業系統實驗報告一[實驗題目]先來先服務FCFS和短作業優先SJF排程演算法[實驗目的]通過本次實驗,加深對程序概念的理解,進一步掌握對程序狀態轉變、程序排程策略及對系統性能的評價方法。[實驗內容]程式設計實現如下內容:1.先來先服務演算法; 2.短程序優先演算法;3.根據排

服務作業優先演算法

先來先服務演算法(FCFS) FCFS是最簡單的排程演算法,既可以用作作業排程,也可以用作程序排程 這種演算法優先考慮系統中等待時間最長的作業(程序),而不管作業所需執行時間長短, 做法是從後備佇列中選擇幾個最先進入該佇列的作業,將它們調入記憶體,為它們分

【計算機作業系統】用java模擬非搶佔式(到、作業、高響應時間片輪轉排程演算法

. 首先,我來介紹一下該程式大致內容 程式使用了ArrayList連結串列來模擬各程序佇列,並且結果會顯示出每個時刻的程序的執行資訊、最後的所有程序的執行結果和程序的執行順序。 ps:各個模擬程式是相互獨立,如果不需要的直接刪除即可。 現在介紹每個排程演算法的思想

作業系統-磁碟排程演算法:服務,最尋道時間優先,scan演算法

1.先來先服務 public class FCFS { /** * 磁碟排程:先來先服務 */ private static int startPosition = 100 ;//磁頭開始位置 private static int totalMoving =

磁碟排程演算法服務排程演算法、最尋道時間優先排程演算法、掃描排程算

一、  實驗目的和要求1.  瞭解磁碟排程技術的特點2.  掌握磁碟排程演算法,如先來先服務(firstcome first served,FCFS)排程演算法、最短尋道時間優先(shortest seek timefirst,SSTF)排程演算法、掃描(SCAN)排程演算法

作業排程之服務演算法C語言實現

程式碼如下 /*    @author WellsLiu    @url liuyanzhao.com*/#include"stdio.h"#include"stdlib.h"typedef st

服務響應優先排程演算法C語言實現

#include <stdio.h> #include <stdlib.h> #include <string.h> #define WAIT "Wait"//就緒狀態 #define RUN "Run"//執行狀態 #define FINISH "Finish"//完

服務排程演算法c++版

作業名                 到達時間      &nb

程序排程演算法 —— 服務

/* 先來先服務 */ #include<stdio.h> #define MAX 50 struct Gzuo{ int id; //程序名字 int dt; //到達時刻 int st; //服務時間 int wct; //完成時刻 float zt; //週轉時間 f

用C語言實現服務FCFS程序排程演算法

**分析:**先來先服務的意思就是哪個程序先到就先進行哪個程序,只與來的先後次序有關,等第一個程序執行完之後才會程序下一個程序的執行。 只有第一個程序的開始時間是它的到達時間,後邊的程序開始時間都是前一個進的完成時間。 完成時間就等於該程序的開始時間加上服務時間 週轉