• time joining CPU burst - arrival time
• ⭐⭐ = turn-around time - CPU burst time

• ⭐⭐ = completion time - arrival time
• (for single process system)

• 
• waiting time: $P_1=0;P_2=24;P+3=27$
• avg.waiting time: $(0+24+27)/3=17$
• avg. turn-around time: $(24+27+30)/3=27$
  • or: $(27+(24+3+3))/3=27$

• 
• waiting time: $P_1=6;P_2=0;P+3=3$
• avg.waiting time: $(6+0+3)/3=3$
• avg. turn-around time: $(9+30)/3=13$
• Convoy effect: short process: stuck behind a long process
  • bad for short jobs, depending purely on arrival order
  • e.g. one CPU -bund & many IO-bound processes
    • FCFS: result in low IO device utilization

• if process takes longer than expectation (e.g. found from the curve)

• once CPU core allocated process, process keeps it until release

• each process w/ small unit of CPU time (time quantum $q$)
  • 10-100 ms
• after time elapse: process is preempted and added to the end of ready queue

• $q$ per each round
• (ignoring context switching)
• waiting time: always less than $(n-1)q$ time units

• upon completing current CPU burst time
• when its CPU burst time / remaining CPU time $<q$
  • i.e. quicker than expectation?

• 
• waiting time: $P_1=6;P_2=4;P_3=7$
• avg. waiting time: $(6+4+7)/3=5.67$
• avg. turn-around time: $(6+4+7+30)/3=15.67$
• response time: $P_1=4;P_2=7;P_3=10$
  • average: 7
  • i.e. first response time - request time
  • 👨‍🏫 same as turn-around for FCFS/FIFO
• remaining CPU burst time

• but inherently "fairer" than FCFS
• offers better average response time: important for interactive jobs

• large $q$: FCFS
• small $q$: interleaved, but high overhead from context switch time
  • context switch time: $<10$ micro sec

is RR: always better than FCFS?

extreme example: quantum = 1

• and 10 jobs starting same time, with 100 CPU burst time

average job turn-around time: much worse

• albeit with two extreme conditions
  • very small quantum size
  • all jobs with same length
• yet: average response time: much better

example

turnaround time: varies with time quantum

• average turnaround time: not necessarily improve when quantum increases
• it can be, generally, when most processes finish current CPU bursts within a single quantum
• yet: large quantum leads to FCFS

⭐ rule of thumb: 80% of CPU bursts: should be shorter than the time quantum $q$

• quantum: should be enough to produce meaningful result for most cases

👨‍🏫 $q$ can be adjusted on the way

• actually... we have better algorithms than pure RR

• for given set of processes, this is optimal (i.e. min avg. waiting time)

• 👨‍🏫 as this is introduction of concepts

• 
• average waiting time: $(3+16+9+0)/4=7$
• best FCFS = case of SJF
• actually,

estimation: done by exponential average (again :p)

• $t_n$: average length of $n$-th burst
• ${\tau }_{n+1}$: predicted value for next CPU burst
• $\alpha ,0\le \alpha \le 1$
  • larger $\alpha$: weight / portion of the most recent data
• define: ${\tau }_{n+1}=\alpha t_n+(1-\alpha ){\tau }_n$

commonly: $\alpha =0.5$

preemptive version: called shorted-remaining-time-first (SRTF)

examples of EMA

• $\alpha =0$: ${\tau }_{n+1}={\tau }_n$
  • first estimation lasts forever
• $\alpha =1$: ${\tau }_{n+1}=t_n$
  • only last CPU burst counts $$\begin{array}{rl}{\tau }_{n+1}& =\alpha t_n+(1-\alpha ){\tau }_n\\ & =\alpha t_n+(1-\alpha )(\alpha t_{n-1}+(1-\alpha ){\tau }_{n-1})\\ & =\alpha t_n+(1-\alpha )\alpha t_{n-1}+(1-\alpha {)}^2{\tau }_{n-1}\\ & =\alpha t_n+(1-\alpha )\alpha t_{n-1}+(1-\alpha {)}^2\alpha t_{n-1}+(1-\alpha {)}^3{\tau }_{n-2}\\ & =(1-\alpha {)}^{n+1}{\tau }_0+\alpha \sum _{k=0}^{n-1}(1-\alpha {)}^k{t}_{n-k}\end{array}$$
• current prediction: dependent on all of past data
  • yet, the effect of past exponentially reduces