1 / 37

Process Scheduling

Process Scheduling. Fred Kuhns. Policy versus Mechanism. Policies set rules for determining when to switch and which process/thread to run Implementation consists of the data structures and algorithms used to implement policy

minya
Télécharger la présentation

Process Scheduling

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Process Scheduling Fred Kuhns

  2. Policy versus Mechanism • Policies set rules for determining when to switch and which process/thread to run • Implementation consists of the data structures and algorithms used to implement policy • Policy and Implementation influenced by platform - for example, context switch cost • Policy must balance needs of different application types: • Interactive, Batch and Real-Time CS523 – Operating Systems

  3. Consider Three Basic Policies • First-In First-Out (FIFO) • runs to completion • Round Robin (RR) • runs for a specified time quantum • Time-Sharing (TS) • Multilevel feedback queues CS523 – Operating Systems

  4. Platform Issues • Interrupt latency • Clock resolution • Cost of a context switch • saving processor state and loading new • instruction and data cache misses/flushes • memory map cache (TLB) • FPU state CS523 – Operating Systems

  5. Typical Scheduler Goals • Interactive • shells, GUI. • Spend most of their time waiting for I/O. • Minimize perceived delay (50-150msec) • Batch • compiles, computations. • Optimize throughput. • Real-time • Require predictable behavior. • May require guarantees on throughput, latency or delay. CS523 – Operating Systems

  6. Some RT Characteristics • Determinism - one measure: delay between interrupt assertion and executing the ISR • Responsiveness - time to service interrupt • User Control • Reliability • Fail-soft operation CS523 – Operating Systems

  7. Clock Interrupts • How system keeps track of time • implemented using a hardware clock interrupt • interrupt at periodic intervals (clock tick) • typically 10msec, see tick frequency defined by HZ in param.h • High priority, second to power-failure interrupt (NMI). CS523 – Operating Systems

  8. Interrupt Latency • time to recognize interrupt and execute first instruction of ISR - Determinism • hardware, for example will CPU finish current instruction. • kernel time to dispatch interrupt to correct ISR • plus time to run ISR • affected by interrupt nesting • plus worst-case interrupt disable time CS523 – Operating Systems

  9. Clock Interrupt Handler • Update CPU usage for current process • scheduler functions - priority computation, time-slice expiration (major/minor ticks) • quota policing • update time-of-day and other clocks • callout queue processing • process alarms • run system processes CS523 – Operating Systems

  10. Callout queue • Queue of functions to be processed at a particular tick • system context, base interrupt priority (sw int) • Example: • packet retransmission, system management functions, device monitoring and polling • for real-time systems insertion time is important • Typical to optimize lookup time not insertion time • time-to-fire, • absolute time, • timing wheel (fixed size circular array) CS523 – Operating Systems

  11. Alarms • BSD: alarm(), setitimer() • SVR4: alarm(), hrtsys() • Real-time - actual elapsed time • sends SIGALRM • profiling - execution time • sends SIGPROF • virtual time - user mode time • sends SIGVTALRM CS523 – Operating Systems

  12. BSD Scheduler • Policy - Multilevel Feedback queues • Policy Goal - good response time for interactive tasks while guaranteeing batch job progress • Priority based, dynamically adjusted • Preemptive time-slicing (time quantum) CS523 – Operating Systems

  13. 4.4 BSD Process Scheduling • Scheduling priority range, hi to lo: 0 - 127 • 0-49 kernel mode • 50-127 user mode • 32 run queues (prio/4 = run queue) • priority adjusted based on resource usage. • time quantum set to 0.1 second for over 15 years! • Sleep priorities CS523 – Operating Systems

  14. Scheduling Related Attributes Predefined Process Priorities PROC structure PSWP 0 while swapping process PVM 4 wait for memory PINOD 8 wait for file control info PRIBIO 16 wait on disk I/O PVFS 20 wait for kernel-level FS lock PZERO 22 baseline priority PSOCK 24 wait on socket PWAIT 32 wait for child to exit PLOCK 36 wait for user-level FS lock PPAUSE 40 wait for signal to arrive PUSER 50 base user priority p_priority (kernel pri) p_usrpri (user pri) p_estcpu p_slptime ... CS523 – Operating Systems

  15. Calculation of Priority • Proc structure: • p_estcpu - estimate of cpu utilization • p_nice - user-settable (-20 to 19, default = 0) • priority (p_usrpri) recalculated every 4 clock ticks • p_estcpu incremented each clock tick process is running • every second CPU usage is decayed • sleeping processes are ignored CS523 – Operating Systems

  16. BSD Formulas • Priority calculation (PUSER = 50) • p_usrpri = PUSER + (p_estcpu/4) + 2  p_nice • Decay calculation - schedcpu ()each second • p_estcpu = (2·load)/(2·load+1)·p_estcpu+p_nice • ex, load=1: p_estcpu = 0.66T4 + … + 0.13T0 • Processes sleeping for > 1 second • p_slptime set to 0 then incremented by 1 ea. second • p_estcpu = p_estcpu·((2·load)/(2·load+1))p_slptime CS523 – Operating Systems

  17. Context switch on 4.4 BSD • Synchronous vs. asynchronous • Interprocess: voluntary vs. involuntary • voluntary - process blocks because it requires an unavailable resource. sleep () • involuntary - time slice expires or higher priority process runnable. mi_switch () CS523 – Operating Systems

  18. BSD - Voluntary Context Switch • Invoke sleep() with a wait channel (resource address) and (kernel) priority • sleeping process organized as an array of queues. Wait channel is hashed to find bin. • sleep() raises priority level splhigh (block interrupts). Set kernel priority (p_priority) • wakeup(): remove process(es) from queue splhigh and recalculate user priority (p_usrpri). CS523 – Operating Systems

  19. BSD - Involuntary context switch • Results from an asynchronous event • kernel schedules an AST, need_resched (), and sets global flag want_resched • current proc checks this flag before returning to user mode. If set, then call mi_switch () • Note: BSD does not preempt process in kernel mode. CS523 – Operating Systems

  20. BSD Interprocess Context Switch • Change user and kernel context • All user mode state located in • kernel-mode HW state - stored in PCB (u area) • user-mode HW state - kernel stack (u area) • proc structure (not swapped) • kernel changes the current process pointers and loads new state. CS523 – Operating Systems

  21. Selecting a process to run • cpu_switch (), called by mi_switch () • block interruptsandcheck whichqs for nonempty run queue. If non, unblock interrupts and loop. • Remove first process in queue. If queue is not empty then reset bit in whichqs • clear curproc and want_resched • set new process (context switch) and unblock interrupts CS523 – Operating Systems

  22. Limitations of the BSD Model • Limited scalability • No resource guarantees • non-deterministic, unbounded delays (priority inversion) • limited application control over priorities CS523 – Operating Systems

  23. Scheduler Implementations • SVR4 • Solaris • Mach • Digital UNIX • Other RT CS523 – Operating Systems

  24. SVR4 Scheduler • Redesigned from traditional approach • Separate policy from implementation • Define scheduling classes • define framework with well defined interfaces • Attempt to bound dispatch latencies • Enhance application control CS523 – Operating Systems

  25. SVR4 Scheduling Classes • Scheduler represents an abstract base class • defines interface • performs class independent processing • Derived classes are specific implementations of a scheduling policy • priority computation, range of priorities, whether quantums are used or if priorities can vary dynamically. CS523 – Operating Systems

  26. SVR4 - Issues Addressed • Dispatch Latencies - time between a process becoming runnable and when it executes. • Does not include interrupt processing. Includes nonpreemptive kernel processing and context switch time. • Kernel preemption points - PREMPT checks kprunrun at well defined points in the kernel • runrun also used as in traditional implementations • Response time - total time from event to application response. CS523 – Operating Systems

  27. SVR4 - Class-Independent • Responsible for • context switching, run queue management and preemption. • Highest (global) priority always runs • priority range: 0 - 160, each with own queue • Default allocations: • real-time 100-159, • system 60-99, • timesharing 0-59 CS523 – Operating Systems

  28. SVR4 - Scheduler Interface CL_TICK CL_FORK, CL_FORKRET CL_ENTERCLASS, CL_EXITCLASS CL_SLEEP, CL_WAKEUP CL_PREEMPT CL_YIELD CL_SETRUN ... CS523 – Operating Systems

  29. SVR4 Class Implementations • Time-Sharing: event driven scheduling. • priority changed dynamically, round-robin within priority, time-slice and priority static parameter table. • System - fixed priority (FIFO). System tasks. • Real-time: fixed priority and time quantum. CS523 – Operating Systems

  30. Solaris Overview • Multithreaded, Symmetric Multi-Processing • Preemptive kernel - protected data structures • Interrupts handled using threads • MP Support - per cpu dispatch queues, one global kernel preempt queue. • System Threads • Priority Inheritance • Turnstiles rather than wait queues CS523 – Operating Systems

  31. Hidden Scheduling • Hidden Scheduling - kernel performs work asynchronously on behalf of threads, without considering priority of requester • Examples: STREAMS process and callout queue • Solaris addresses by using system threads • run at kernel priority which is lower than the RT class. • Callout processing is also a problem. Solaris uses two different callout queues: real-time and non-real-time (callout thread). CS523 – Operating Systems

  32. Priority Inversion • Low priority thread holds a resource required by a higher priority thread. • Partial solution - Priority Inheritance. • High priority thread “lends” its priority to the lower priority thread. • Must be transitive • kernel keeps a synchronization chain CS523 – Operating Systems

  33. Priority Inheritance in Solaris • Each thread has a global and inherited priority. • Object must keep a reference to the owner • If requester priority > owner, then owner priority raised to that of the requesters • This works with Mutexes, owner always known • Not used for semaphores or condition variables • For reader/write, • owner of record inherits priority, only partial solution CS523 – Operating Systems

  34. MACH • Inherited base scheduling priority which is combined with a CPU usage factor • CPU usage factor decayed 5/8 each second inactive • threads set own priority after waking up. • Clock handler charges current thread. • Every 2 seconds, system thread scans run queue and recomputes priorities (addresses starvation) • Fixed quantums, preemptive scheduling • handoff scheduling - used by IPC CS523 – Operating Systems

  35. MACH MP Support • No cross processor interrupts • processor sets • thread runs on any of the processors from the assigned set. • Processor allocation can be handled by a user-level server • Gang scheduling • dedicate one processor per thread. • Minimize barrier synchronization delay CS523 – Operating Systems

  36. Digital UNIX • Time-sharing and real-time classes: SCHED_OTHER, SCHED_FIFO, SCHED_RR, • Highest priority process is always run • Priority range: 0-60 (0-29 TS, 20-31 SYS, 32-63 RT) • nonpreemptive kernel • no control for priority inversion CS523 – Operating Systems

  37. Digital UNIX - MP • Per processor dispatch queues • Scheduler will move threads between queues to balance load • soft affinity CS523 – Operating Systems

More Related