High level scheduling: Medium level scheduling: Low level scheduling. Scheduling 0 : Levels

Transcription

1 Scheduling 0 : Levels High level scheduling: Deciding whether another process can run is process table full? user process limit reached? load to swap space or memory? Medium level scheduling: Balancing the system load swap out a process? swap in a process? Low level scheduling Deciding which process should get CPU time next.

2 Scheduling 1 : Objectives System throughput should be maximised. Graceful degradation of performance. No sudden collapse! Provide a tolerable response time. Consistent behaviour, wrt job priority and from day to day.

3 Scheduling 2 : Criteria Job Priority : Depends on Category of job: batch, on-line, real-time. CPU bound or I/O bound. Resource requirements Waiting time to date. Resources used to date.

4 Scheduling 2.5 : Low-level Decisions Factors that can affect priority: deadline by which task MUST complete; cpu time, time spent actually running; wall time, cpu time + waiting time; total cpu time required; memory needed; external priorities assigned to process; repetition of process;

5 Scheduling 3 : Low-level Low-level scheduling can be: Preemptive Current process may be interrupted by o/s. new process arrived interrupt placed blocked process in Ready queue clock interrupt (time up). Non-Preemptive Process executes until it terminates blocks on I/O or system call. Cooperative As non-preemptive except that process may give up cpu voluntarily.

6 Scheduling 4 : Low-level Policies i First-come-first-served, or FIFO. Non-preemptive. first process to arrive in queue gets CPU when this process stops running, next in queue gets CPU ie. the process that has been waiting longest goes next. favours cpu-bound processes. Round Robin Uses a time-slice and preemption. each process runs for a short period when timer expires, or process blocks, next process runs design issue is length of time-slice. favours cpu-bound processes

7 Scheduling 5 : Low-level Policies ii Shortest job first. non-preemptive process with shortest expected processing time goes first. need to calculate processing time for each job. risk of starvation for long jobs Shortest remaining time preemptive version of SJF process with shortest remaining processing time runs. preempted if new shorter job arrives in queue. risk of starvation again. need to know process run time.

8 Scheduling 6 : Low-level iii. Highest Response Ratio Next non-preemptive. process with the highest ratio of waiting time : run time goes next. Favours shorter jobs. Doesn t starve longer jobs Still need to know how long the job will take to complete. Priority = waiting time + runtime runtime

9 Scheduling 7 : Low-level iv.i Multi-level feedback queues preemptive Run Queue 0 CPU Run Queue 1 Run Queue 2 after Operating Systems, 5th Ed. Stallings, Prentice Hall

10 Scheduling 8 : Low-level iv.ii Long processes can get starved, therefore : time quantum = τ Process first placed on RQ0 gets time slice of length τ x 2 0 If process does not complete then move to RQ1 gets time slice of length τ x 2 1 If process does not complete then move to RQ2 gets time slice of length τ x 2 In general a process on RQ i gets time slice of length τ x 2 i

11 Scheduling 9 : Generic Unix Traditional time-sharing, multi-user, interactive system. Uses multi-level feedback with round-robin queues. Preemption after 1 sec. Priority is recalculated every second using Where CPU j (i) = CPU j(i 1) 2 P j (i) = Base j + CPU CPUutilization j (i) by j in time i P j(i) j (i) priority + nice of j at 2 j start of i Basebase j priority of process j from Operating Systems, W. Stallings 5th Ed. Pearson. nice j user adjustment for j Process with the lowest value has the highest priority

12 Scheduling 9.1 : generic Unix Queues are, in order of priority Swapper Block I/O device control File Manipulation Character I/O Device control User Process

13 Scheduling 10 : Linux pre 2.6 Linux has one run queue, but uses several scheduling policies, a number of priority levels and a niceness factor to control scheduling: Niceness is in the range -20 to +19, (user processes only) The priority is recorded in the priority field of the task_struct and is in the range 0-99 The policy is recorded in the policy field of the task_struct Policies are SCHED_RR, SCHED_FIFO, SCHED_OTHER

14 Scheduling 10.1 : Linux pre 2.6 SCHED_RR process base priority fixed for life in the range Round-Robin scheduling runs until it blocks itself -> moved to wait Q preempted by higher priority process -> run Q uses up its quantum -> moved to run Q SCHED_FIFO process base priority fixed for life in the range First come first served scheduling runs until it blocks itself -> moved to wait Q preempted by higher priority process -> run Q it completes current task -> moved to run Q

15 Scheduling 10.2 : Linux pre 2.6 SCHED_OTHER Used for all normal processes. Process base priority fixed at 0 Process has niceness factor which affects quantum. The counter field in task_struct is the quantum for a process. Decremented every clock tick when process running. Scheduler called when value = 0. counter field value recalculated as follows counter = Scale_Factor (20 (nice) + 1) The Scale_Factor is based on the processor speed and is to ensure that the standard quantum is around 50ms.

16 Scheduling 10.3 : Linux pre 2.6 Remember, all runnable processes are held in the same queue! The scheduler decides which process to run next by calculating the goodness factor for all tasks on the RUNNABLE Q. For policies SCHED_RR SCHED_FIFO goodness = priority which puts real-time processes way above ordinary processes with a goodness of between 1001 and 1099

17 Scheduling 10.4 : Linux pre 2.6 SCHED_OTHER is a bit more complex, recalculate goodness : goodness = p->counter; if (p->processor == this_cpu) goodness += PROC_CHANGE_PENALTY; if (p->mm == this_mm!p->mm) goodness += 1; goodness += 20 - p->nice; goto out; If goodness is zero for all RUNNABLE processes then recalculate all processes as p->counter = (p->counter >> 1) + NICE_TO_TICKS(p->nice); ie. counter = priority + ( counter/2 )

18 Scheduling 11 : Linux 2.6 Scheduling in 2.4 kernels does not scale well therefore a new scheduler... O(1) process selection time is constant irrespective of load however many CPUs New scheduling data structure(x2) per processor. struct prio_array { int nr_active; /* #tasks in array */ unsigned long bitmap[bitmap_size]; /* priority bitmap */ struct list_head queue[max_prio]; /* priority queues */ } MAX_PRIO has a default value of 140. BITMAP_SIZE = 5 ( 140/32 = 5 ) nr_active = total # of tasks on all queues

19 Scheduling 11.1 : Linux 2.6

20 Scheduling 11.2 : Linux 2.6 On startup :- active queue & expired queue bitmaps zeroed; Then When a process is ready to run it is assigned a time slice, place on the appropriate priority queue, bit set in active priority array. If process is preempted then returned to the active queue for its priority else if time slice expired then placed on relevant expired queue time-slice is reset. If priority queue is now empty then clear bit-field in priority bitmap

21 Scheduling 11.3 : Linux 2.6 Select next process to run from highest priority non-empty active queue. If more than one task in queue then select using round-robin Multi-Processor Systems compare task load for each processor transfer tasks, starting with high priority tasks. Priorities & Timeslices Static priority Ordinary processes range from 100 to 139, default 120. Dynamic Priority function of static priority and process behavior. I/O bound processes are favoured. Can change with kernel compile time options. Timeslice ranges between 10ms - 200ms.

22 Scheduling 11.4 : Linux 2.6 Scheduling Policies: Real-time tasks are assigned static priorities. SCHED_FIFO has no time slice, runs till complete or blocked (returns to active priority Q) or preempted. SCHED_RR has assigned timeslice which never changes, runs till timeslice expired, (returned to ACTIVE Q, not expired) blocked, (returns to active Q) No switch to expired queue list until NO ready SCHED_RR tasks.