QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 2057|回复: 0
打印 上一主题 下一主题

【计算机操作系统】作业调度算法的 C++ 实现(附源码)

[复制链接]
字体大小: 正常 放大
杨利霞        

5273

主题

82

听众

17万

积分

  • TA的每日心情
    开心
    2021-8-11 17:59
  • 签到天数: 17 天

    [LV.4]偶尔看看III

    网络挑战赛参赛者

    网络挑战赛参赛者

    自我介绍
    本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。

    群组2018美赛大象算法课程

    群组2018美赛护航培训课程

    群组2019年 数学中国站长建

    群组2019年数据分析师课程

    群组2018年大象老师国赛优

    跳转到指定楼层
    1#
    发表于 2021-4-9 15:36 |只看该作者 |倒序浏览
    |招呼Ta 关注Ta
    # S# a1 A; w8 G' z; Y0 F" N0 M
    【计算机操作系统】作业调度算法的 C++ 实现(附源码)
    % @. C/ [" n" C2 l+ D文章目录& X; Q( {; T/ P+ {
    一、实验目的
    " f6 l9 R  h0 h1 ~3 d3 g' j二、实验内容
    8 J4 s  F' f9 U# M3 f2.1 单道处理系统的作业调度
    3 f/ v  o' I2 C, n0 d/ o2.2 多道程序系统的作业调度
    8 I! H: O# D) w三、流程图5 L" b9 _4 }  g  q3 _
    3.1 单道批处理系统的作业调度
    5 g# w* m% J0 Q四、设计思想
    % \1 H. M, j: t* e: m+ P4.1 设计思路
    0 E' s) M) c6 l/ o4.2 单道批处理系统7 Q  Z% u, a" z! j' h& h
    4.2.1 代码结构
    / o9 b1 s( y7 T; R. ]2 B9 ]7 P4.2.2 FCFS
    : |* B) C% `3 z" k! c' c. @4.2.3 SJF
    ! P- z, |5 F- B7 j' y1 F4.2.4 HRRN
    2 c$ f  s0 d+ ]8 Q4 c3 C. X. M4.3 多道批处理系统
    5 U- @3 A; e5 [- w% D4.3.1 FCFS + PSA3 b  L' H: U  W6 d
    五、代码实现+ |( l' p3 {  I( s
    六、运行结果! }% T! S4 q8 K1 e
    6.1 单道批处理(FCFS)( _2 K; n; V/ u' j1 \
    6.2 单道批处理(SJF)
    ; O4 u+ T" p$ Z! t( P9 N6.3 单道批处理(HRRN)
    ( K/ d  a$ a. ]6.4 多道批处理(FCFS + PSA)6 U- ]2 c# h: F" F
    七、结尾. L# z1 T$ v9 l6 K
    一、实验目的. C9 Y: a; F& g2 \9 Y: Y
      用高级语言编写和调试一个或多个作业调度的模拟程序,以加深对作业调度算法的理解。因为源码中我对一些关键步骤的注释已经比较清晰了,所以在本文中不会再对每一个细节都进行分析,只分析整体的代码结构和所使用到的设计模式。
    ' n6 T1 \- G) I/ C  _/ S& H  t# ]7 Z. K, s+ F: T; c9 N* q
      博客内所有文章均为 原创,所有示意图均为 原创,若转载请附原文链接。' i; F/ m: v; e; q4 y
    2 D0 K  c6 |0 \- }+ F) b/ [6 D
    二、实验内容
    5 A& o2 s' I. Y) z8 T9 z1 V7 {- Z2.1 单道处理系统的作业调度
    . q' U$ Q( U) @& T  作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRRN)的调度算法。
    7 k/ {9 S' d# ?# ]$ h# e  对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间,以比较各种算法的优缺点。
    ( o% ]" ^7 T+ n  t7 ^( z5 Q3 M" Z9 U. O) u4 [0 {0 K+ w0 s! t
    2.2 多道程序系统的作业调度
    4 ?8 W5 ^8 Y. B& y+ V" l  作业调度算法:采用基于先来先服务的调度算法或基于优先级的作业调度算法。* N3 {" V+ w, R# G
      对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。- }. P6 k7 Q( F( w1 _1 @
    # |6 W5 O+ h4 b. G# ?" U
    三、流程图2 L9 ~4 ~" H% y1 c, C* d/ _
    3.1 单道批处理系统的作业调度
      s" u! V& W! r5 c% C- i' A
    6 U/ ?: Y+ P. n+ s3 k$ ?
    , N/ w5 {2 K6 p( q2 M3 n, T四、设计思想
    / X0 g+ `8 @/ V; K4.1 设计思路7 n( B' _  }( a" M4 `
      对于单道批处理系统,由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU时限等因素。3 S8 F5 Q' `+ x
      作业调度算法:采用先来先服务(FCFS)调度算法,即按作业提交的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。每个作业由一个作业控制块JCB表示,JCB可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。9 b* v* n# b' z, v% A% C
      作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。各个等待的作业按照提交时刻的先后次序排队,总是首先调度等待队列中队首的作业。每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间,这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。
    + E5 l" t- Q* G3 b, r" l8 @4 w# c而对于多道批处理系统来说,作业调度(响应比)按一定的算法从磁盘上的“输入井”中选择资源能得到满足的作业装入内存,使作业有机会去占用处理器执行。但是,一个作业能否占用处理器,什么时间能够占用处理器,必须由进程调度来决定。所以,作业调度选中 了一个作业且把它装入内存时,就应为该作业创建一个进程,若有多个作业被装入内存,则内存中同时存在多个进程,这些进程的初始状态为就绪状态,然后,由进程调度(优先数)来选择当前可占用处理器的进程,进程运行中由于某种原因状态发生变化,当它让出处理器时,进程调度就再选另一个作业的进程运行。 因此,作业调度与进程调度相互配合才能实现多道作业的并行执行。
    + C% f1 J+ g% g, {. [; k& X2 V( S, R/ D. Y# h4 t
    4.2 单道批处理系统# {6 @7 B9 j" u7 b4 c& i7 l& M# y. g
    4.2.1 代码结构
    - n5 O5 {' a5 M  T# ~  因为这里的单道批处理系统需要实现多种算法,因此使用了 模板方法设计模式 + 策略模式 来进行开发,下面为各种算法的类签名,算法的具体实现可见代码实现。
    8 c9 L# J  z1 @5 h$ s; }6 C$ W: I+ g9 m
    /* 单道批处理系统基类 */
    7 H) L! F6 a: F& y0 @$ k2 rclass SchedulingAlgorithm;
    & W  P% ^8 o5 w: u! c% V
    5 e) P% x1 t' t$ T5 A! W/* First-Come First-Served 先来先服务算法 */
    / M5 c3 y. ~0 m6 \3 S0 F. Sclass FCFSSchedulingAlgorithm : public SchedulingAlgorithm;
    9 k; R2 T# ^% B- o8 k$ q
    0 Y/ L& w$ `/ K+ s/* Short Job First 短作业优先算法 */
    5 e# v" J2 \+ Z; K/ c, ?class SJFSchedulingAlgorithm : public SchedulingAlgorithm;3 g- l' Y, b$ ^3 X

    9 f8 n1 Z3 o$ g( f4 W- D/* Highest Response Ratio Next 高响应比优先算法 */
    & c9 M# ^: g8 }( h; G- aclass HRRNSchedulingAlgorithm : public SchedulingAlgorithm;
    & z2 R+ m: W% X  G1 x* |* @0 K1/ p- T) \8 S9 Z0 D* w5 h) r
    2) L/ E/ C5 j7 ?* P
    3. J! w: V% L/ p* H: X1 L
    4
    : N. Q  s' c+ o  V& }51 s) y/ N4 p( B/ i% J7 E
    6
    7 r0 S8 i0 J6 C7
    3 t1 Z' g) p5 p$ [8# S; j5 w7 [( u5 ~: V
    9
    3 n/ ]2 R# v6 d0 t1 Y* ^( q2 ~  \10
    5 Q8 u1 P' _- [5 m7 ^2 c5 H11
    ( v9 c5 J! H5 c' u: y$ E1 W+ T  y) \4.2.2 FCFS1 d7 `5 a5 ?7 _5 S
      因为这里使用优先级队列来实现,所以我们只需要为每种算法定义不同的比较函数即可,比如对于FCFS算法来说,它的比较算法就是比较该作业提交的时间。
    8 I& [5 G# k2 ~1 }
    . J4 Q8 K: W8 c- X2 W+ Z// First-Come First-Served' R% `3 y7 E! j9 ]  F5 ?
    class FCFSSchedulingAlgorithm : public SchedulingAlgorithm$ @" ~7 {1 P$ @/ v
    {
    + q6 i& L2 Y# D& M/ o. Rpublic:
    ; z( w3 s2 y2 @$ U( p) _( _        struct PriorityCmp% A/ a) b5 x4 _& \
            {7 D# t9 t8 `* u9 `3 c( S9 \
                    bool operator()(const JCB j1, const JCB j2)
    + b3 v  _; |8 B. ~                {" N- h* Z+ W3 C& w/ h% W
                            return j1.submit_time > j2.submit_time;
    * J; O( u" T7 d" ]                }
    8 _8 J) q. R) D; z# D' i8 I        };
    ! y/ d- m; @$ M* P- K  `
    7 c; t; X1 @( b/ A$ p! j        FCFSSchedulingAlgorithm(){}+ \1 ~2 R3 r: r: g
    };
    & |  u1 E1 J7 j/ q7 a- H* f1
    8 j  v( E- }: U2# }/ y! ^$ [6 i+ w+ P# W3 b
    3
    6 m! X3 u. w9 Q+ E4
    7 k5 l! T( @; Z# m! X) j, y: J5
    - R! K6 X, P0 B: ]5 C8 R0 j1 M6
    & k7 ~6 [/ t" e5 S* p% j% Q7
    6 h7 `+ \' x6 {* o% r( D0 `% h85 Y& j6 O7 e2 W/ s9 v: F7 c( k
    9" S+ A/ H2 @) Y; d0 B
    10, x% B3 g# H6 P! }
    11
    ; J) X5 m- L* e8 ]. E" j127 m) q' c0 A& _1 r) a  \
    13
    ) f/ f! e5 t$ s  Q  {  S14
    ) c7 |9 E% J4 t; r: J& ~4.2.3 SJF7 J. ]$ M2 D' h
      对于SJF算法来说,它的比较函数就是比较作业的时间长度(时间越短优先级越高)。" a4 C7 A) l- _
    , Z+ g/ x6 X2 H# C$ e
    // Short Job First
    1 w/ x+ u3 R) u- Bclass SJFSchedulingAlgorithm : public SchedulingAlgorithm
    ' e: A* Z  C: w& e{+ Z" c! J: d0 o8 Y
    public:) j) B  p6 e9 N$ o
            struct PriorityCmp
    ( X6 d2 W+ A6 I& ~" v7 v( A3 o        {2 Q, ^+ ?6 w( H8 O$ F7 b
                    bool operator()(const JCB j1, const JCB j2)  u# {4 Z, ?; `
                    {
    / t, X; c6 t/ L2 o) w                        return j1.required_running_time > j2.required_running_time;
    ' J: o# C7 m, N8 b+ v6 k5 V' a                }
    9 ~1 T( m0 H, g6 U/ B, J        };% f& x* B* ^+ [! `: S# x+ {, Y+ E7 x/ M
    ( u& {0 v; N6 L3 `* V$ V& n) V& K
            SJFSchedulingAlgorithm(){}
    - ]( n' Q$ K  ?4 q};5 [8 L" l% q! l3 t$ j
    1
    7 E9 o9 [9 N2 u: F" J, z2, E, ?+ X3 ^5 a" V$ \
    3
    ) w6 A; |/ ~& |/ D2 l3 _. M42 B+ F+ t8 O) B  X& A4 K
    5
    $ u/ e9 f% _9 l6 h  V$ u) L# L6
    2 I0 y( o- ?0 q5 d0 D7
    7 |8 @9 N4 i5 k4 \+ a5 V; k8
    2 m9 [! C; ]  u/ I; ~9 X8 b  }96 E0 q0 d3 F) L$ Q+ F  h3 y) _  Y
    10" P' P5 p6 w; u5 q! c( J" X% ]3 C- w
    119 u/ d9 o. Z& w/ e  ]6 x
    12; l  J) P: N  a' Z; y
    13
    2 T+ m: j4 z) v0 z" v" |; z( {14
    6 f# V8 O5 E6 \/ \- E4.2.4 HRRN
    ) ?2 k  \$ ~, D, M* D; d7 L  该算法的比较函数比较的是每个作业的响应比:(等待时间+要求服务时间)/要求服务时间,响应比越高,优先级越高,越优先被调度。
    + V) Z4 @% H( |: Q1 y7 q6 F$ P, ?: f7 a. Y  |, g% ]  N) O% Q1 @
    // Highest Response Ratio Next: V7 J$ \' S7 K7 H! V  Z) X
    class HRRNSchedulingAlgorithm : public SchedulingAlgorithm
    9 T* H, D* U3 D{
    6 c/ E) Q, B! `9 Tpublic:
    ! f, z5 [& m5 y! B; Z7 w        struct PriorityCmp4 M; {! _9 c5 M! t$ M
            {
    4 q0 y( n& B3 e                double getPriority(JCB jcb)& e+ [# n, L4 Y0 Z
                    {
    4 [; t. J) _' X/ b8 I8 Q; ?                        return ((cur_time - jcb.submit_time) + jcb.required_running_time) / jcb.required_running_time;
    , l, W" L1 J# @( H                }
    % q& x& V) `' K2 ?" ~. H& _, \% r* m' ?" r1 x
                    bool operator()(const JCB j1, const JCB j2). k4 v3 H$ s2 }; X8 `& `
                    {
    ) ~5 Q) _- S2 H                        return getPriority(j1) > getPriority(j2);5 q( O4 x% ]: N5 q9 j/ c9 O
                    }# ]( k3 Z' N4 k3 P, M+ S
            };7 K) B/ J- h! y7 G1 O% [( {

    8 d3 N, Q6 j3 q! m' C3 S+ ^        HRRNSchedulingAlgorithm(){}6 J1 Q- H7 k; G( u5 ^
    };4 v# F6 @& m4 {7 o  O
    18 U' X: i+ F/ T
    2! |+ H2 S& D/ Q
    3
    % Z+ g+ e) ~" P, s- H0 e# b. w' R; B4
    , M" v4 V; S4 o9 n$ ?5
    ) [! }. k7 H+ T; C) A6
    % {9 I' x+ Y0 M! R. @, Z$ X7% ]) J& z$ _& f) V
    8( G* V4 I4 a0 O1 i* f) O
    9* r5 ]  _8 L! E: |1 O: P: C
    10# }1 X& o2 D1 n. {/ j5 a" w
    11
    : S) o/ I7 n, B: \122 P8 r$ u, V& A4 ]5 a$ ]" }: I& }
    13
    1 I7 S4 G4 t; u8 t14
    0 W4 s2 \' ?. F) D7 J15
    * J* L- p, U! ^: |$ o2 K) P16( m9 n3 c9 h( Z2 g, ~2 ]% t7 Y
    17! q) @: n0 ?! w% D8 t
    18  T9 }0 Q, T, d8 T4 q. g
    193 N: y7 O2 u( i0 m4 `3 P
    4.3 多道批处理系统
    ( f  b% r/ m8 O4.3.1 FCFS + PSA( s9 [  _$ L3 I6 ?$ I7 d
      对于多道批处理系统来说,情况会复杂一些,因为对于多道批处理系统,除了作业的调度还存在进程的调度,也就是作业调度决定该任务能不能使用处理机(有没有资格),但就算该任务被调度了,因为多道批处理系统,还需要考虑相关的资源,因此能不能使用到处理机,还要看进程的调度。% @* I# L1 ~4 U4 ~7 x1 S6 ^* F6 u% @
      因此在这里对于作业调度采用了FCFS算法,而对于进程的调度采用了PSA算法(静态优先级,可抢占),并且没有继续使用实验一中的进程调度算法的代码,而是重新写了一遍。- v4 r  M" m$ v9 X  v; r5 r
      所有的任务初始会被存放在 back_queue 中,而就绪的任务和正在运行的任务都存储于 psa_ready_queue 中,等到 psa_ready_queue 中存在空间时,会通过任务调度算法从 back_queue 中选择合适的任务进行调度,当任务(准确说是进程)被调到 psa_ready_queue 中后,会根据它的优先级判断它是否能够优先运行,如果不能就只能保持就绪状态,一直等到优先级高的进程运行完毕后再运行。* C3 M5 M$ L  ^3 [6 F; v$ [4 U
      因为这部分代码的逻辑比较复杂,所以就不在这里单独罗列了,具体可见下面的代码实现。需要注意的是多道批处理系统代码逻辑中被注释掉的代码为测试代码,可以使用其来对代码的准确性进行测试。+ Z$ c8 y; q6 I1 Z" L+ u6 O9 a. Z+ C

      C  n6 X  v" G8 l1 k9 a五、代码实现
    ) K$ R. y( m) Q) ?2 a#include <iostream>
    4 t) l' u. y3 Y1 L. ?/ \3 X) A#include <string>
    5 G) E7 Q3 E' P! y3 f#include <vector>
    6 l* B# t# w: Z) }#include <queue>
    6 m0 A' J8 L5 }7 S# O, y/ o; N- S7 o#include <cstdlib>
    + ?; U- P3 x: z' S#include <ctime>% ?" s  {  r+ I2 k% t
    #include <unistd.h>3 ?& r- I# @" W% _
    #include <iomanip># U9 w. c; ^$ z  z8 j- ?; M

    " _2 g) g2 c/ J6 R8 s$ gtypedef int TimeSlice;
    # x4 o1 |  r* X; e3 [4 b1 btypedef int Resource;
    1 s  Y2 I5 z* F. H  Mtypedef std::queue<TimeSlice> * JobTimeSeries;
    0 s1 P5 G2 I% z( `  Y5 A  H, N/ }+ u% Z0 \
    TimeSlice cur_time = 0;; o& J* u) U3 w1 T' P# L0 K
    int average_turnaround_time = 0;. o; A* _$ r1 r, O
    double average_power_turnaround_time = 0;$ o$ i% S4 q7 s! ]$ V/ u$ Q& X

    / Z& U1 |) ?! v0 d' renum ProcessStatus
    . e$ y) c- |* ]: d{
    # _4 G' y& @  ~3 S3 w( h2 I7 K        Ready = 0,
    + |  g% k5 z% F: q/ _        Running = 1,1 W7 l! [4 P. o2 Y% a# S; D
            //Finish = 2
    . z$ o5 {3 B1 `: C. V};
    * `+ A2 [. R9 G' a: N
    4 r2 f: w4 f  o, f' a6 l. _typedef int Pid;. n; T; G- O1 k6 Z* S
    typedef int TimeSlice;- a! e9 n! O1 q& c+ O# e8 v: v1 O2 l( ]
    typedef int Priority;" s$ z+ ?4 {/ E, _

    & m7 p+ u2 V- V+ estruct JCB;
    0 m0 g3 Y8 Y* n+ Btypedef JCB * JCBptr;
    ' \% t) Y2 y5 D5 {1 H) o% @, E
    9 S8 m* z/ F  `9 `1 I# T6 B9 V. Mstruct PCB$ o6 O1 `& G- }
    {" ~& o7 M" {; {! a. ]$ x7 h
            PCB(JCBptr jcb_) : jcb(jcb_){}7 z: }5 W. |" y
            Pid pid;
      c9 T9 Z& P: ?# U4 G        ProcessStatus status;
    9 _& n& B2 r- c; d/ p( p1 @        Priority priority;
    6 P! `' v6 l) p5 f& `9 _, {        JCBptr jcb;
    % `$ R2 e' G5 J};
    - H3 Y5 A) J8 l
    1 W% m) g; G+ [  o& p* ztypedef PCB * PCBptr;
    ' `- v, H) g9 f/ T6 R2 Y( d( E) ~  U
    4 ~( G# w( y" [: W) Z' genum JobStatus
    / k# K" |+ i' ~+ P. a: u{3 w: o% p# ~" b) i
            Wait = 0,1 g3 }% @: `" l
            Run = 1,
    ' G8 @7 e. a+ A$ K6 \        Finish = 2& W: A& g5 q) U7 ]( H; c
    };3 {" G+ }, H$ R8 s. X6 G

    9 x4 u  }9 r9 [: C1 `2 `, gstruct JCB
    ! P: Z. D3 [4 k+ m{/ ?1 B, ~/ b3 W9 y
            std::string job_name;' i7 r; `  H5 i# S: R
            TimeSlice submit_time;8 Q6 }6 G0 q- P, S$ H6 q
            TimeSlice required_running_time;
    . S/ u  e- W  t; l0 q1 x$ ]) W; E) E* j
            TimeSlice start_time = -1;+ |. |# |; r' f+ C* E
            TimeSlice finish_time = 0;
    7 h  Y: d4 A6 Q        TimeSlice already_run_time = 0;
    0 K6 c0 H1 S/ |4 T- T! S3 }8 t/ M  t6 l
            Resource required_resource;2 ~6 u% q. k: [  U; u2 B. O
            JobStatus job_status;* J7 I5 i9 \( v
            PCBptr pcb = new PCB(this);
    % @  N, N! i+ M. ^  j) g};
    ! I# c, R/ D: N6 n8 Z. Y/ m2 h5 b" w! @
    3 Z5 T4 `0 u6 n/ R  R
    class Util" o! l' |" K) p5 d! ^+ d
    {
    : m; w. j. I' ^% spublic:
    * j( j0 y3 Y+ i5 a, ]        static inline int getRandom(const int min_val, const int max_val, int match)! K: M1 L: r0 r% v' \9 o
            {
    ) |: _. H8 u$ g: [+ Q# c$ @                srand(time(0) + match);  k. P) G$ P- d3 O) x
                    return rand() % (max_val - min_val - 1) + min_val;
    ) B& L. s! X( E        }
      j  S1 ^# W4 ?$ [. U8 l7 N% p# s+ H( }" r
            static inline bool printJobData(const JCB jcb)$ |% O7 n. c+ S6 ~
            {$ E$ s0 z. g& _/ A
                    TimeSlice start_time = cur_time;
    ) N9 S) |; T- \9 s. r- ]0 K' y                TimeSlice finish_time = start_time + jcb.required_running_time;
    " Q. H: d2 h$ Q+ x$ c+ Z8 I                TimeSlice turnaround_time = finish_time - jcb.submit_time;
    2 v9 ]# f! Q/ D. r, ~- I                double power_turnaround_time = turnaround_time / (jcb.required_running_time / 1.0);; ^- o; O& P6 f8 O; A( F8 V
    ; A% @5 _! Y3 m( v8 E+ U
                    std::cout << "[Data] " << jcb.job_name << " "
    ( A, ~$ P; o0 M! Q7 M. C( O                        << " Start time: " << start_time << " "
    9 o# ]  D8 h9 |& `4 a                        << " Finish time: " << finish_time << " "/ a* O9 l! F; a2 r
                            << " Turnaround time: " << turnaround_time << " "
    2 ?- ^( R5 I+ I) [! E                        << " Power turnaround time: " << std::setprecision(2) << power_turnaround_time << std::endl;/ e7 Y" M0 S1 p' E& V

    # V) O1 R+ ?. ~1 l2 n- A  h1 ~( ^, Z7 H
                    average_turnaround_time += turnaround_time;
    8 A4 d; w+ b! U& ?1 ^6 ]                average_power_turnaround_time += power_turnaround_time;9 ~6 @3 Q$ a1 Q. L* i5 g3 ~0 b
    & s3 O9 J, c: Z3 v' n
                    return true;
      A6 N3 }! T9 [# F) ?9 X; q        }
    5 m0 ], k; L1 L/ N) M( e2 {1 P
            static inline bool printJobData(const JCB jcb, bool isMul)/ ]* Q" r6 d0 A1 G% l  U2 z
            {$ T/ F/ j% D, S
                    TimeSlice turnaround_time = jcb.finish_time - jcb.submit_time;  E7 ^/ ~1 V0 ?' U  Q& J( W
                    double power_turnaround_time = turnaround_time / (jcb.required_running_time / 1.0);
    ) y5 g1 k+ f% k2 I3 O2 k6 Q# f0 h5 n% Z& h
                    std::cout << "[Data] " << jcb.job_name << " "2 L% t4 M0 S; N* T
                            << " Finish time: " << jcb.finish_time << " "# ^* Q6 M+ }0 r
                            << " Turnaround time: " << turnaround_time << " ": w2 ]; b$ d6 ^% I4 f
                            << " Power turnaround time: " << std::setprecision(2) << power_turnaround_time << std::endl;7 l. R- ?" ]& W6 M, v# V
    $ s; ~, }8 Y6 Z( ?& Z
    , K7 r( d+ u5 b& k5 d% l
                    average_turnaround_time += turnaround_time;5 D6 w) ?" ]6 C
                    average_power_turnaround_time += power_turnaround_time;) Y- c  z$ r9 B0 X: [
    # y3 k0 M5 }  V
                    return true;
    7 u$ ^0 [1 p, a7 d! U        }2 R. w8 K( S' l7 _
    };
      M3 M! }3 [, B0 Y  p5 \( i3 T3 {1 s7 ~# a5 T
    class SchedulingAlgorithm
    9 l" K5 d: m* y( i{. n2 m+ a6 r0 }. f, o  N
    public:3 ]% z0 G# E' |! `& T" x: q- u5 W$ j

    4 E% S. ~1 j% l1 F7 ]//        virtual bool initPCB(std::priority_queue<JCB, std::vector<JCB>, std::less<JCB>> * ready_queue, int process_num) = 0;
    & I/ N1 m( i7 f0 c# W4 k% D4 B//        virtual bool processPCB(JCB & pcb) = 0;8 z; \6 F: W* g8 g
    };( n9 j5 p5 T, d/ N4 {; V
    : D: [3 A& _' d* r! V" v  r0 R
    // First-Come First-Served: `- {7 r* I* l0 h* G; B. {- v
    class FCFSSchedulingAlgorithm : public SchedulingAlgorithm$ E9 ?( }! g  d- y- d* l
    {( ?8 ]/ m0 J! t+ L. O. x) {  J
    public:" X: s+ X* A- e4 Q1 A
            struct PriorityCmp
    7 B) q5 u) c+ P8 J+ |: s        {
    * S+ a2 k; ~- c5 p6 d: O5 m  Y  I                bool operator()(const JCB j1, const JCB j2)* |$ m- c0 M8 J/ G& r. h6 O
                    {4 W9 {7 y- R6 X2 ~4 h, k3 M6 [
                            return j1.submit_time > j2.submit_time;& F7 e* ^  m* Q+ B
                    }8 A% t& B! j  l: y
            };* y+ Q' B& D1 Z$ i5 o* L( p  Z) ^

    6 Z! _" Z) i+ ~        FCFSSchedulingAlgorithm()
    0 e) E$ Y, q  @% P" J        {}! N6 N$ p' ^3 i+ T$ Y0 C5 ~  g
    8 K9 V1 h' ^' L& q
    private:) g- K1 x% q0 J' }2 }8 S( p# [) W

    . j" a; L5 u' i0 T! v& l- r( v: d3 I& w  T7 l
    };# z* E% S2 X! C: m. s

    2 R4 {9 d! s1 t# }) r/ c// Short Job First3 f0 [$ k5 n8 c9 H* p
    class SJFSchedulingAlgorithm : public SchedulingAlgorithm
    ( f' g9 d7 t5 x# B1 D{
    % t( e3 m: X/ D& U* ~# H. ppublic:
    ! _, _* w0 \) F/ h2 g4 T4 V        struct PriorityCmp0 d! m$ S4 Q) |* v$ o
            {
    % ^! g" i0 d9 x5 Q3 v; H                bool operator()(const JCB j1, const JCB j2)& Z% u7 i: `7 v+ J% d, _4 @5 K* r
                    {
    3 D. P2 e: q8 L' P, L4 h8 W3 [0 x2 S2 j                        return j1.required_running_time > j2.required_running_time;( m( G( d0 U  N4 c
                    }7 W& |( m. M6 a8 w9 O# [, e+ x2 L
            };$ [" Q4 \# K6 z. e- F8 C

    7 f- R+ ~0 d7 W9 I        SJFSchedulingAlgorithm()
    8 W9 E$ C% l+ c! w% [3 h        {}
    2 [- X4 X3 V  O0 {9 u* `& Q
    0 R. R2 b+ ~: X* q5 r};
    , h0 ^5 }5 g! x+ @3 E  n
    8 I  ]  q  f& z, j// Highest Response Ratio Next
    8 y" P2 ~9 q( ]8 Z7 eclass HRRNSchedulingAlgorithm : public SchedulingAlgorithm! P+ e. K" R" W" \, N! m
    {
    . d6 k2 }7 N1 d/ b$ M( Upublic:5 k& e$ `& B$ }, ^. z' t$ F
            struct PriorityCmp' s0 O7 o3 C$ J( H' J
            {  M7 K, n+ h* d; @/ T2 ^' L+ M
                    double getPriority(JCB jcb)7 ~- u0 v: k4 `9 k- ^- O. y
                    {
    ) r) e# @! r* D% V" j6 j& d' w                        return ((cur_time - jcb.submit_time) + jcb.required_running_time) / jcb.required_running_time;) A. n9 n0 j' b( [5 c  a0 D# _
                    }8 z+ i1 j7 G- O( {# D3 c- Y5 X
    * }( ~. X$ U7 m7 A
                    bool operator()(const JCB j1, const JCB j2)( s+ U, f0 G; l
                    {
    / O: b! L) s5 e                        return getPriority(j1) > getPriority(j2);
    ( g  N# |# o0 G                }, x4 G* c3 p& w% w! L
            };- }2 e* `+ Y8 N$ ~3 r" ]
    - [5 q5 U* Y4 f+ Q  P, o% e
            HRRNSchedulingAlgorithm()2 K* J. b" I+ l$ Q/ F7 Y
            {}7 J0 \% F7 f4 T4 w9 p; _
    };3 F# n' _) U5 u! F
    7 X! I) p( Y, a1 j
    template<typename PriorityCmp>" [! p: J! q1 P7 f
    class JobScheduling
    * p5 p- |6 w! o. K3 }9 a{( D1 G  e% w4 x- O' @
    public:
    9 e1 v* ^9 j( D, O        JobScheduling(int job_num)
    ( l- Q( o# I' h$ f: ]        {
    6 f- Z! x3 T& J! ?8 E9 k                job_num_ = job_num;7 `2 Q/ d7 x9 [. i" q) _$ x( H* w
                    sa_ = new SchedulingAlgorithm();
    0 |% {- n  h& h5 a* B+ X                wait_queue_ = new std::priority_queue<JCB, std::vector<JCB>, PriorityCmp>();
    . \* R# y+ ]& w% f                mock_jcbs_ = new std::priority_queue<JCB, std::vector<JCB>, PriorityCmpForMock>();
    7 J3 H- ~7 l9 n                finish_queue_ = new std::queue<JCB>();
    . N) j! u2 y4 {' E% q, t* [! `  R; c" _. @6 o' l6 B8 v/ ^7 F
                    mockJCBs();2 G0 Y% [6 b, A, e) }
            }9 m3 [  E) G9 j8 b1 u
    ( r8 I! Y* I3 z3 z2 n, X
    protected:
    2 x0 l  Y, K! V0 o        struct PriorityCmpForMock/ d( B/ d( o) P' O- ^- P
            {, c; P0 U- [. s8 f
                    bool operator()(const JCB j1, const JCB j2)5 j4 H/ ~! k) L1 `6 M
                    {
    + M1 L/ N$ n- C                        return j1.submit_time > j2.submit_time;8 x% [1 ]" Z+ C( v- R+ W+ u
                    }
    " j1 f0 [) a( O* |" x3 W5 N        };
    0 v# A; a! I" P1 }6 I' ^: k" @, {8 j# d; z( P( }% i2 Y
            bool mockJCBs()4 ~$ k0 T7 P% O: d5 ^& x7 T2 ^
            {
    ' ]4 ~6 j8 p9 z                for (int i = 0; i < job_num_; ++i)
    * R/ |0 J& k, ]9 w8 p' f                {8 F1 E. z1 m8 b8 U6 w
                            JCBptr jcb = new JCB();* Z* K* n: S6 V, q2 K
                            jcb->job_name = "job" + std::to_string(i);4 _  L, T# x$ [+ Q4 |
                            jcb->job_status = Wait;
    9 f) N/ Y5 `3 Y                        jcb->submit_time = Util::getRandom(1, 20, i);
    ( A7 u0 k& Z. U                        // The minimum value is 3 so that each segment can be divided into time slice
    * ]) q& m0 l; u0 K6 f                        jcb->required_running_time = Util::getRandom(3, 10, i);4 v* ?4 R4 @$ t3 h; k+ z/ b/ e2 q
    * j, U/ H, o; _1 u4 E7 ~
                            mock_jcbs_->push(*jcb);" c3 L7 X$ z' Z1 @% K% m
                            std::cout << "[INFO] finish init " << jcb->job_name << " with "% Y- _! S& c/ G
                                    << " submit_time " << jcb->submit_time+ l/ B4 ~$ N5 m4 W' a
                                    << " required_running_time " << jcb->required_running_time << std::endl;
    * ?* c0 `8 a9 o( H% b' f                }: U! a1 t3 ]; f6 b2 K" ^0 c
            }" S" _5 Q  X- ^5 a. G+ k# ?

    2 B! q! h; z1 b; t' B1 |        void getCurrentReadyQueue()2 ]: K* g9 a6 U* |0 [" Y2 E
            {
    1 a7 g4 S' O3 w6 @8 O$ g; L0 O                while (!wait_queue_->empty())
    / p4 e1 L: c5 S1 X; \: _6 z                {
    - s: h1 e) l  \                        JCB jcb = wait_queue_->top();0 K+ ?1 N% L- w- u5 ~) @: k
                            std::cout << jcb.submit_time << std::endl;
    7 S! L& E. [7 n! K  Y8 x                        wait_queue_->pop();
    ( x" [9 C" H) P  B+ f/ |' H                }
      ?! I8 P- v- k/ h. D  V        }
    * M4 J4 _$ I5 C$ e2 h0 K+ j. y6 b$ b
            int job_num_;
      U3 q& i0 m# ~' I0 I* b, {        SchedulingAlgorithm* sa_;
    ; D+ J$ X8 f6 ], N7 j  j+ N: z! ]        std::priority_queue<JCB, std::vector<JCB>, PriorityCmpForMock>* mock_jcbs_;
    1 [( H: i5 W, {        std::priority_queue<JCB, std::vector<JCB>, PriorityCmp>* wait_queue_;: L! d3 c& j- E
            std::queue<JCB>* finish_queue_;
    2 a% j5 j( p6 m1 ?7 s1 o( x  T};" [0 A( B2 f; C; l4 P& e3 y7 s; [
    ! Q* y4 T& T4 G
    template<typename SchedulingAlgorithm, typename PriorityCmp>9 n/ B% j8 |# w- ^/ u7 |
    class SimpleBatchProcessingSystemJobScheduling : JobScheduling<PriorityCmp>& |$ V7 E/ M! E
    {3 a% W- k  E) \3 c8 `
    public:
    6 t2 v9 \" h' U, y: ]$ F        SimpleBatchProcessingSystemJobScheduling(int job_num)
    / Z+ q4 P, W- F1 b$ T# \8 H' v. {                : JobScheduling<PriorityCmp>(job_num)0 ]% o. |) f. N2 s) v" f
            {}# V; i! l+ ]2 `0 u4 l& |+ m) y
    , |0 q$ D' s: M
            bool start()2 j  A) z: b; W( x# ^  n3 g, {
            {
    ( w! n9 {4 T2 p; D                cur_time = this->mock_jcbs_->top().submit_time;
      A2 l0 n5 e+ m) t) Z( a  i( x                while (!this->wait_queue_->empty() || !this->mock_jcbs_->empty())& W* s5 Z% s9 J5 Y
                    {# L$ l5 H4 Y5 O9 U
                            // Simulate adding tasks dynamically' z, |' W/ P% P- m
                            if (!this->mock_jcbs_->empty() && this->mock_jcbs_->top().submit_time <= cur_time)
    ! b: E) c( M+ `+ y6 W0 J                        {8 F+ g) j4 [6 f* q: L$ V
                                    JCB jcb = this->mock_jcbs_->top();
      v" D: X) ]- M7 B                                this->mock_jcbs_->pop();
    + u, n# V8 I/ t; K7 T4 t, I4 R( {8 ?
                                    std::cout << "[INFO] add " << jcb.job_name <<  " to wait queue." << std::endl;7 E5 b/ X; e# f# ~* H
                                    this->wait_queue_->push(jcb);  c9 O. I8 y/ j
                            }
    / k: S; T- T' u  T5 M7 j. x+ }
    * t$ K. q5 g/ C; R                        if (!this->wait_queue_->empty())
    5 K' {, v) U4 v                        {
    8 @. h! s; i4 e; m2 B7 s                                JCB jcb = this->wait_queue_->top();
    & _' q+ j2 S- n' q8 A9 }                                this->wait_queue_->pop();
    # _4 o9 X( a& C+ ^* r+ e' b+ q) O  |2 f0 ?0 T8 M% \
                                    std::cout << "[INFO] begin to do " << jcb.job_name << "." << std::endl;9 e4 r' b9 ]2 @/ B" h6 y* G" f
                                    jcb.job_status = Run;1 O, z0 U3 l4 J: K1 A
                                    // simulation do job
    ( h: R$ }; x0 U7 |                                sleep(1);
    % g& W2 y6 o' f* i8 R( Y% e- f                                std::cout << "[INFO] do " << jcb.job_name << " finish." << std::endl;% k- Z( @/ Q# ~# J' p
    + |* c8 C* l4 n; X5 E( v
                                    jcb.job_status = Finish;8 _6 i( m6 \3 ^
                                    // print job Data.& S. a" Q, @# x) J, i" h  x
                                    Util::printJobData(jcb);
    % R2 a4 I# z, F1 v; f3 ?2 d8 Q                                this->finish_queue_->push(jcb);. \" L* c& {! P) F! Z' c. ?+ f6 K
                                    cur_time += jcb.required_running_time;
    1 O" g, g1 }  E/ h; T1 V. V                        }
    0 G4 {. k4 O$ `                        else
    / P4 o3 g& I9 h0 k) r& ]                        {
    . g0 y2 L: G$ M3 X. w  P) m4 u# R) Y! R                                // Slowly increase time slice when there is no job7 d& _3 g! V: c4 V( g6 ]
                                    cur_time += 1;
    % f/ l  b7 R3 J                        }9 ~% k& V1 x4 N$ u  h7 X
                    }
    % v" i3 w1 B0 |" f5 j/ L& y( S  l                std::cout << "[INFO] all jobs finished." << std::endl;5 s" {! ]1 ?$ E$ p
                    std::cout << "[LOG] average turnaround time " << (average_turnaround_time / this->job_num_)
    ) |# A7 U- T4 o& m3 X- M& H                        << " average power turnaround time " << (average_power_turnaround_time / this->job_num_) << std::endl;( ?: |( J/ M' ^( z. Z1 s) J
            }
      d+ L+ f% F5 |- A) Z7 M# |) J( \, Y3 o: h
    private:0 P4 I) }3 a0 P/ r
    5 c. [8 t5 F9 [6 _0 G8 ]( x
    };) Q+ i' F& t# K

    7 L0 Y# F4 u0 O2 t2 C
    % B  L0 D- L+ M: Iclass MultiprogrammedBatchProcessingSystemJobScheduling
    . s7 S; U$ l2 u4 C{, j, e5 t4 g, b( u; x- C
    public:. e7 L) l2 y3 N+ \0 S" p
            struct PriorityCmpForPCB
    3 z: A! O4 x9 U2 B. e4 X        {
    % e+ R6 j1 r. U+ u' B8 P" M                bool operator()(const PCBptr p1, const PCBptr p2). q* M& I# L+ O: P0 i
                    {; [5 h& ]7 S5 h( U
                            return p1->priority < p2->priority;
    0 k  i- P- s" z- l! C: T                }
    4 H. ?4 B. R6 o+ R7 k8 H        };
    % D" R- C% l5 g' `. M) K
      d7 k, J% ~% G+ P        struct PriorityCmpForBack4 V% X  g! g6 U0 C7 y7 }
            {0 d/ d& }9 c4 F1 V, ^  f
                    bool operator()(const JCBptr j1, const JCBptr j2)
    0 k: J* k" O3 i# r                {6 f$ O, ^% b( E7 l4 L# M
                            return j1->submit_time > j2->submit_time;
    6 r2 x. X6 Y9 p0 c$ y- ^! d/ H                }2 b) N- n% e. x
            };
    6 U& r2 T5 z+ C% B+ P+ D1 b& T5 G4 K& L) l. n
    ' T7 L1 `: o$ v' ^7 N6 [: @+ `
            MultiprogrammedBatchProcessingSystemJobScheduling()
    8 N2 n% O, e8 N5 j$ w        {
    % u' c" B. V9 R# Y% x+ F                back_queue_ = new std::priority_queue<JCBptr, std::vector<JCBptr>, PriorityCmpForBack>();
    ' b! v6 m" L5 @4 F9 J& r                psa_ready_queue_ = new std::priority_queue<PCBptr, std::vector<PCBptr>, PriorityCmpForPCB>();0 @4 p( j/ [. V, \, A- _- _5 N

    + B! l& x' o( t. H& t, q                0 B$ b. x* X" Z& k$ O
                    std::cout << "input job num:" << std::endl;
    , p4 h- M/ ~  c: N                std::cin >> job_num_;/ U; {$ t4 s5 m2 U" _* y- X
                    for (int i = 0; i < job_num_; i++)
    4 O1 I; k1 X4 j; l/ Q                {
    + Q# ?; `, X0 j5 w                        std::cout << "input job" << i << " submit_time & required_running_time & priority" << std::endl;
    6 F0 l) j# {7 x! n7 A. v1 l3 T7 e                       
    : Q: O7 _2 u; X                        JCBptr jcb = new JCB();
    1 e8 }' [; b. E0 |% I                        jcb->job_name = "job" + std::to_string(i);# B+ T3 W5 J# W2 C/ t8 s# W0 `
                            jcb->job_status = Wait;
    ( E! o( _& N) p                        std::cin >> jcb->submit_time;
    * {+ J; G5 d0 a/ Y( e8 C                        std::cin >> jcb->required_running_time;
    6 K7 K: J1 @: ~* V( P: Q                        std::cin >> jcb->pcb->priority;6 V8 H% k4 l. g! M+ t( b1 ]- m
                            back_queue_->push(jcb);- G# {1 C+ ]) C5 t+ O' b0 f& ]
                    }- E. ^) ]2 y. }7 q, r
                   
    / J- h2 C8 P* V4 j8 T. G                /*
    ) S4 e) {4 A7 N% t0 Q# e                job_num_ = 6;1 z6 b0 e7 J0 F
    0 U5 |9 w8 w% c6 w. w8 y# O
                    JCBptr jcb = new JCB();0 E+ c% C" K& r7 z) v
                    jcb->job_name = "A";, }$ x/ c% q/ C& W$ i
                    jcb->job_status = Wait;4 k+ B0 |' H" a6 {% P
                    jcb->submit_time = 0;
      {8 @" P/ z* t4 c4 q5 W. g                jcb->required_running_time = 50;
    ; e5 y/ J% |9 K- s                jcb->pcb->priority = 5;
    2 O- X) A  z, s6 M                back_queue_->push(jcb);
    1 m  I! _3 V- S  \! v! ?, \5 L
    1 I+ y. ?( l0 |/ Z" G* Z                jcb = new JCB();
    , V" y2 \9 A4 |. {6 N0 C* [                jcb->job_name = "B";
    * C5 k# N. y- h. f% {5 ^2 p4 n                jcb->job_status = Wait;$ l" R. v' D/ b# h2 G
                    jcb->submit_time = 20;
    5 S' e; H" R$ v/ i* i3 }. C                jcb->required_running_time = 60;
    ) I1 |0 F9 `( ~/ N9 W) Z                jcb->pcb->priority = 7;4 K1 M/ n7 X% A3 H/ C3 x5 q
                    back_queue_->push(jcb);5 i' v0 c) g% N- y; K
    " b# b) O9 r3 n% l/ f2 G: H
                    jcb = new JCB();" ?+ ^$ L  v- B' k! D0 K
                    jcb->job_name = "C";) q4 _; F) p( B. C
                    jcb->job_status = Wait;
    ) P2 P" d) I& J* E                jcb->submit_time = 50;
    ) a$ \* I, V' v* c2 a                jcb->required_running_time = 40;
    4 u$ C8 c" f4 K3 o5 A& D$ `. P/ t& ]                jcb->pcb->priority = 3;
    2 h! ?* r  T) C- w                back_queue_->push(jcb);) A* W5 a. ^# t3 {
    ( b7 G+ L  B  P0 }. {0 w0 T
                    jcb = new JCB();  u& c, f. E% z' u- l9 R7 F6 m# S5 v
                    jcb->job_name = "D";
    3 h" y2 U0 x5 R* l3 c6 v$ s                jcb->job_status = Wait;
    . ?( G- M. K) U8 ]                jcb->submit_time = 80;# @& y1 u# p4 ]3 X
                    jcb->required_running_time = 80;
    4 R5 F' S/ `; N                jcb->pcb->priority = 8;9 l0 n! E% S9 E; ]% V! w
                    back_queue_->push(jcb);
    1 s) q7 i! W% @9 H: |! p. V9 `$ {5 Z2 ]5 Z1 i' I" d  k2 Z
                    jcb = new JCB();, o7 f1 r5 ^# M4 N
                    jcb->job_name = "E";
    9 l. i4 a* \( A8 N7 Q2 i                jcb->job_status = Wait;' a) A5 e$ p( {
                    jcb->submit_time = 100;
    ; H. U. v8 T( i                jcb->required_running_time = 30;
    9 w, w7 _  A$ H9 c5 n/ y, M                jcb->pcb->priority = 6;
    * B) m. e8 t, q8 K! X) S                back_queue_->push(jcb);
    , O! V" B! S" s' e4 p7 n" `% X/ h, p0 Q7 l, h! M
                    jcb = new JCB();
    ( c- ?( S! l9 \* A- h                jcb->job_name = "F";% F3 w0 L# C/ p% e
                    jcb->job_status = Wait;, P. |8 q  M0 w- r" \/ ^/ `$ a3 |+ L
                    jcb->submit_time = 120;3 q. t/ L, `$ d7 ?0 k
                    jcb->required_running_time = 70;8 p  d0 ^$ y6 w
                    jcb->pcb->priority = 9;7 b5 e+ U  I* ?# z1 D" F
                    back_queue_->push(jcb);8 S% S- C) {3 y! ?/ W  ?% F9 N
                    */
    3 r- v1 F- z: k5 A  \        }: {+ Q5 d, Y0 @1 H" y, v

    9 l: d) O  L+ L1 U5 {# w        bool start()$ a" z1 c) ~0 z& q5 @3 A) C
            {
    ' c# X( h* r+ w5 ]                cur_time = back_queue_->top()->submit_time;/ {& ?; o& F$ j  [: V
                    while (!back_queue_->empty() || !psa_ready_queue_->empty())
    3 |4 a" t5 {  `5 E; j  r! v3 t7 E: v                {3 `% w1 D' R1 }
                            bool increase_time = true;8 ?/ B' [: [; \% H$ b
                            // Job FCFS; H/ c7 C0 M' e, \' t
                            if(!back_queue_->empty() && psa_ready_queue_->size() < 2)1 r8 u) i6 u" u1 ^# @
                            {* U  Q& M$ J; f' [& ~
                                    JCBptr jcb = back_queue_->top();- {: A. N" |& ^4 O- @
                                    if (jcb->submit_time <= cur_time)
    - M# b! G' w! B                                {6 Y6 G1 g/ J! E& e
                                            back_queue_->pop();
    . B  d" _* U1 f+ _3 x: ?2 v  y
    & w, Z. l$ {4 Z( D+ e# t8 \. {                                        // Process PSA
    5 ]" K5 T8 `8 k# I9 U8 y                                        if (!psa_ready_queue_->empty())
    2 a+ W7 Z5 G$ @                                        {
    8 ?6 n, n7 _0 @4 E4 ^' q! a( \                                                PCBptr pcb = psa_ready_queue_->top();6 o8 O7 U0 _4 e0 y6 g# b
                                                    JCBptr jcb = pcb->jcb;8 N2 n5 V" X% [4 H$ m+ u0 G

    ; ]' _+ G4 S1 G; |( X                                                if (jcb->already_run_time >= jcb->required_running_time)$ _  }. h# J& ~+ P& ]: e  `/ D* z
                                                    {
    : q& v8 R' B$ I7 Q7 F  e; ?                                                        jcb->job_status = Finish;2 J; O9 R$ e2 q6 I' c
                                                            psa_ready_queue_->pop();5 B1 Q9 c( a! t4 ^) l1 K! |
                                                            //std::cout << "[LOG]" << jcb->job_name << " Finish At " << cur_time << std::endl;
    8 \+ i2 n4 A& @8 o" P; Z* T$ a5 D; V/ \. B1 Q
                                                            jcb->finish_time = cur_time;
    . S2 ?# W$ \' N' Z3 c                                                        Util::printJobData(*jcb, true);
    ; l$ |5 p/ x0 ]$ q1 q                                                }
    ' a8 }& l4 t; h( j: D7 c                                                else
    * k0 q, i# A: R& D                                                {
    6 X$ Q! R8 X' r- S# k: p/ \                                                        jcb->job_status = Wait;
    1 {1 R2 Y( }& e4 k1 j& ?8 u                                                        pcb->status = Ready;( p: F+ y9 X) x# C$ m+ S( u
                                                            //std::cout << "[LOG]" << jcb->job_name << " Ready At " << cur_time << std::endl;- S7 `( U0 M1 U& x$ c, _3 T
                                                    }
    6 Y% ~$ U6 t5 i+ m                                        }
    - D- u/ @  _6 N1 y) ?& p
    & `" R* e% N$ s" v* ~9 v, b                                        psa_ready_queue_->push(jcb->pcb);
    - [# K$ i" r) _) I5 G$ N) y' R1 A5 i
                                            PCBptr pcb = psa_ready_queue_->top();
    : m7 T& P3 t! ^. {                                        JCBptr jcb = pcb->jcb;
    # K: }& ~  p" Z7 \7 G' A/ v                                        jcb->job_status = Run;
    ; F" j' x/ w! d" w0 o7 A                                        pcb->status = Running;1 ]6 Q; r- {1 i3 s5 w" J8 K
    # b2 L* P1 n. |  x
                                            //jcb->start_time = (jcb->start_time == -1) ? cur_time : jcb->start_time;
    0 j% [! b6 x+ ^                                        //std::cout << "[LOG]" << jcb->job_name << " Begin Running At " << cur_time << std::endl;$ J3 t; g$ P+ H3 t; P$ k1 `
    - S* l  g- }9 a4 Q; G$ S3 _
                                            increase_time = false;* ]/ z' O2 z6 J* k/ @) x
                                    }
    5 I) k5 g- I5 q! z3 F! a" r                        }
    % W' u2 J/ y. }9 L' V% k: X                        else if (!psa_ready_queue_->empty())" @2 M3 K$ n4 c% ?, |
                            {
    " e( g: r7 L' o7 g9 Z                                PCBptr pcb = psa_ready_queue_->top();
    1 M0 f, G9 j' j                                JCBptr jcb = pcb->jcb;
    . T8 f, P3 i2 T4 M. E9 K
      B9 V6 k- s0 q0 Q* F; k                                if (jcb->already_run_time >= jcb->required_running_time)/ Y+ t- J' l' R) r- X
                                    {" \) r4 L9 E. O1 u4 X
                                            jcb->job_status = Finish;3 P& G+ u& b+ `
                                            psa_ready_queue_->pop();
    1 m% H/ j1 B" o5 v1 g3 U7 U2 z                                        //std::cout << "[LOG]" << jcb->job_name << " Finish At " << cur_time << std::endl;
    . n4 ~  j- I  J                                        jcb->finish_time = cur_time;
    7 k' Z+ y1 P4 w+ [7 J6 k                                        increase_time = false;/ {9 y' n1 c+ {6 A- p; o+ c/ b7 n
    ' |. @2 T) s" P5 ]% s
                                            JCBptr jtop = psa_ready_queue_->top()->jcb;
    + K6 l4 ~# b( x% `                                        //jtop->start_time = (jtop->start_time == -1) ? cur_time : jtop->start_time;8 Z/ `) {$ l# {2 T; G
                                            Util::printJobData(*jcb, true);
    5 I/ t! O- n' l) b                                }
    - r) ]! j" U1 b6 M) f( E! D                        }% n4 F8 D  {$ p) b% x# A3 z5 v4 _
                            * {2 }' z* p2 G: [5 v! C
                            if (increase_time)8 o4 G) b' `: k6 n
                            {6 U5 x: Y2 m5 y
                                    if (!psa_ready_queue_->empty())3 L" i" {1 H: U0 g0 H0 g# K
                                    {# }3 X: }) z7 ?  ^# f; S; Y
                                            PCBptr pcb = psa_ready_queue_->top();
    / _* J- u/ k4 L' Z) v                                        pcb->jcb->already_run_time++;4 K% W, J2 R! V
                                    }4 W; F! ^. T. n
                                    cur_time++;
    , F5 k3 ^! N. g; p7 g6 K                        }
      H! e5 V  F) A7 b. b                }
    9 G7 [- O( W+ p+ r: ]                std::cout << "[INFO] all jobs finished." << std::endl;
    . t$ }  [8 o% u% W, X2 n* r6 V                std::cout << "[LOG] average turnaround time " << (average_turnaround_time / job_num_)9 r( |' ]9 [" ~* @
                            << " average power turnaround time " << (average_power_turnaround_time / job_num_) << std::endl;# D1 ~$ O8 l! [6 e% T8 U6 D' a
            }( i4 D6 N+ j5 I0 z7 F; B/ c
    & z+ }" _1 t# T0 f" T- s
    private:
    9 `! B! A  x: G, B, O5 w6 t+ |4 l        int job_num_;# a. t5 w# e" e3 r2 s9 F; R
            std::priority_queue<JCBptr, std::vector<JCBptr>, PriorityCmpForBack>* back_queue_;; z8 c  W8 \* C! d. b
            std::priority_queue<PCBptr, std::vector<PCBptr>, PriorityCmpForPCB>* psa_ready_queue_;
    ! h2 Y5 K6 \: ]7 l* S, I};+ _* g/ ^1 ~  a1 T: y7 k! }: h
    - t+ ^  q$ I8 y' G# N# ?3 o
    /*" \0 \' k4 P% y$ g1 O
    int main(), @$ V6 O$ E' n4 b8 o0 c
    {. @2 L0 g" O8 q" e3 t+ `4 g
            SimpleBatchProcessingSystemJobScheduling<FCFSSchedulingAlgorithm> js(4);1 O# P0 D3 F# _
            js.getCurrentReadyQueue();
    ( K- y, g+ _# H9 m7 |" @3 K1 V$ e. }) D
            // pause to see result# g7 V' I& ]5 h/ A% K# p- @
            getchar();
    9 a& f" U" f4 W' h! B2 X        return 0;
    . |; y. p, W' t! ^5 N}% _9 V# M9 M6 A. M( R" P% k
    */8 c4 ]" u8 ]1 H
    ' C, w  q5 G. l* f: r8 S$ [
    六、运行结果
    * m/ g2 i0 _" H3 e; L) A" D6.1 单道批处理(FCFS)" J; S# b2 R  U, b6 d, u1 E4 r

    7 I2 f* \8 j( N3 a
    ' n* a$ g" \3 b: ^! e6.2 单道批处理(SJF)
    # `% i' y/ m" x8 ]" g6 a* F# Q  d# W! `% a6 x8 `
      n2 ~$ J" c/ F/ H2 k
    6.3 单道批处理(HRRN)8 F! b5 f* I0 i$ _- u2 [+ U+ A
    . ^3 V- S/ z  Z: A" J
    . J3 [: L) q, T4 G$ c9 B
    6.4 多道批处理(FCFS + PSA)  e9 _3 r. S6 K* C2 X
    $ a- b7 W3 E+ ?8 K, O6 \

    # {" j8 d3 H# @# H七、结尾
    4 M6 {( ]2 ~7 a; S. w3 B/ ?2 J0 \  如果本文描述的内容或使用的代码存在任何问题,请及时联系我或在本篇文章的下面进行评论,我会本着对每一位学技术同学的负责态度立即修改。在后续还会有三篇计算机操作系统的算法 C++ 复现博文,如果感兴趣可以关注我。
    / z5 G/ w' V. s/ H$ `————————————————5 _# u. j, s- @7 r3 s
    版权声明:本文为CSDN博主「杨小帆_」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。; O% [9 @  {1 W# H
    原文链接:https://blog.csdn.net/qq_40697071/article/details/106698130
    4 N! ?/ w1 o8 N$ d) h
    2 f; U  i0 k7 U+ [0 M
    4 G( V% f# w. h: Y% w& s
    zan
    转播转播0 分享淘帖0 分享分享0 收藏收藏0 支持支持0 反对反对0 微信微信
    您需要登录后才可以回帖 登录 | 注册地址

    qq
    收缩
    • 电话咨询

    • 04714969085
    fastpost

    关于我们| 联系我们| 诚征英才| 对外合作| 产品服务| QQ

    手机版|Archiver| |繁體中文 手机客户端  

    蒙公网安备 15010502000194号

    Powered by Discuz! X2.5   © 2001-2013 数学建模网-数学中国 ( 蒙ICP备14002410号-3 蒙BBS备-0002号 )     论坛法律顾问:王兆丰

    GMT+8, 2026-4-20 21:03 , Processed in 0.461438 second(s), 51 queries .

    回顶部