What Runs A Paramount In Ground Pool Cleaning System

Operating System Scheduling algorithms

A Process Scheduler schedules different processes to be assigned to the CPU based on particular scheduling algorithms. At that place are six popular process scheduling algorithms which we are going to discuss in this affiliate −

Kickoff-Come, Starting time-Served (FCFS) Scheduling
Shortest-Job-Side by side (SJN) Scheduling
Priority Scheduling
Shortest Remaining Fourth dimension
Round Robin(RR) Scheduling
Multiple-Level Queues Scheduling

These algorithms are either non-preemptive or preemptive. Non-preemptive algorithms are designed and then that once a process enters the running state, it cannot be preempted until it completes its allotted time, whereas the preemptive scheduling is based on priority where a scheduler may preempt a low priority running process anytime when a high priority procedure enters into a fix country.

First Come Get-go Serve (FCFS)

Jobs are executed on first come, first serve basis.
It is a not-preemptive, pre-emptive scheduling algorithm.
Easy to understand and implement.
Its implementation is based on FIFO queue.
Poor in performance as average wait time is high.

First Come First Serve Scheduling Algorithm

Expect fourth dimension of each process is every bit follows −

Process	Wait Time : Service Time - Arrival Time
P0	0 - 0 = 0
P1	v - one = 4
P2	viii - 2 = 6
P3	16 - 3 = 13

Average Expect Time: (0+4+6+13) / 4 = 5.75

Shortest Chore Next (SJN)

This is likewise known as shortest job first, or SJF
This is a not-preemptive, pre-emptive scheduling algorithm.
Best arroyo to minimize waiting fourth dimension.
Easy to implement in Batch systems where required CPU fourth dimension is known in accelerate.
Impossible to implement in interactive systems where required CPU time is non known.
The processer should know in advance how much time procedure will take.

Given: Table of processes, and their Arrival time, Execution time

Process	Arrival Time	Execution Fourth dimension	Service Fourth dimension
P0	0	5	0
P1	1	3	5
P2	2	eight	14
P3	3	6	viii

Shortest Job First Scheduling Algorithm

Waiting time of each process is every bit follows −

Process	Waiting Time
P0	0 - 0 = 0
P1	v - 1 = four
P2	14 - 2 = 12
P3	viii - 3 = 5

Average Wait Time: (0 + 4 + 12 + five)/4 = 21 / 4 = 5.25

Priority Based Scheduling

Priority scheduling is a non-preemptive algorithm and one of the nigh common scheduling algorithms in batch systems.
Each process is assigned a priority. Process with highest priority is to exist executed offset and so on.
Processes with same priority are executed on starting time come up first served footing.
Priority can be decided based on memory requirements, time requirements or any other resource requirement.

Given: Table of processes, and their Inflow time, Execution fourth dimension, and priority. Here we are considering ane is the lowest priority.

Process	Arrival Time	Execution Time	Priority	Service Time
P0	0	5	1	0
P1	1	iii	two	11
P2	2	eight	1	14
P3	3	half-dozen	3	5

Priority Scheduling Algorithm

Waiting fourth dimension of each process is every bit follows −

Process	Waiting Time
P0	0 - 0 = 0
P1	eleven - one = 10
P2	14 - ii = 12
P3	5 - iii = 2

Average Look Time: (0 + ten + 12 + ii)/iv = 24 / 4 = half-dozen

Shortest Remaining Fourth dimension

Shortest remaining fourth dimension (SRT) is the preemptive version of the SJN algorithm.
The processor is allocated to the task closest to completion but it tin can be preempted by a newer ready job with shorter fourth dimension to completion.
Impossible to implement in interactive systems where required CPU time is not known.
It is often used in batch environments where brusque jobs need to requite preference.

Round Robin Scheduling

Round Robin is the preemptive process scheduling algorithm.
Each process is provided a set time to execute, it is chosen a quantum.
One time a process is executed for a given time menses, it is preempted and other process executes for a given fourth dimension flow.
Context switching is used to save states of preempted processes.

Round Robin Scheduling Algorithm

Wait fourth dimension of each process is as follows −

Process	Expect Time : Service Time - Arrival Time
P0	(0 - 0) + (12 - iii) = 9
P1	(three - 1) = 2
P2	(6 - 2) + (14 - 9) + (20 - 17) = 12
P3	(ix - 3) + (17 - 12) = 11

Average Wait Time: (9+2+12+eleven) / iv = viii.5

Multiple-Level Queues Scheduling

Multiple-level queues are not an independent scheduling algorithm. They make use of other existing algorithms to group and schedule jobs with common characteristics.

Multiple queues are maintained for processes with common characteristics.
Each queue can have its ain scheduling algorithms.
Priorities are assigned to each queue.

For example, CPU-bound jobs can be scheduled in 1 queue and all I/O-bound jobs in some other queue. The Process Scheduler then alternately selects jobs from each queue and assigns them to the CPU based on the algorithm assigned to the queue.