Editing Scheduling (computing) (section)

==={{Anchor|PROCESS}}Process scheduler===
The process scheduler is a part of the operating system that decides which process runs at a certain point in time. It usually has the ability to pause a running process, move it to the back of the running queue and start a new process; such a scheduler is known as a ''[[Preemption (computing)|preemptive]] scheduler'', otherwise it is a ''[[Nonpreemptive multitasking|cooperative]] scheduler''.<ref>{{cite web|access-date=2023-06-19|author=Paul Krzyzanowski|date=2014-02-19|title=Process Scheduling: Who gets to run next?|url=https://www.cs.rutgers.edu/~pxk/416/notes/07-scheduling.html|website=cs.rutgers.edu}}</ref>

We distinguish between ''long-term scheduling'', ''medium-term scheduling'', and ''short-term scheduling'' based on how often decisions must be made.<ref>{{cite book |author=Raphael Finkel |author-link=Raphael Finkel |url=https://www.yumpu.com/en/document/read/32199214/an-operating-systems-vade-mecum |title=An Operating Systems Vade Mecum |publisher=Prentice Hall |date=1988 |chapter=Chapter 2: Time Management |page=27}}</ref>

===={{Anchor|LONG-TERM}}Long-term scheduling====
The ''long-term scheduler'', or ''admission scheduler'', decides which jobs or processes are to be admitted to the ready queue (in main memory); that is, when an attempt is made to execute a program, its admission to the set of currently executing processes is either authorized or delayed by the long-term scheduler. Thus, this scheduler dictates what processes are to run on a system, the degree of concurrency to be supported at any one time{{snd}} whether many or few processes are to be executed concurrently, and how the split between I/O-intensive and CPU-intensive processes is to be handled. The long-term scheduler is responsible for controlling the degree of multiprogramming.

In general, most processes can be described as either [[I/O-bound]] or [[CPU-bound]]. An I/O-bound process is one that spends more of its time doing I/O than it spends doing computations. A CPU-bound process, in contrast, generates I/O requests infrequently, using more of its time doing computations. It is important that a long-term scheduler selects a good process mix of I/O-bound and CPU-bound processes. If all processes are I/O-bound, the ready queue will almost always be empty, and the short-term scheduler will have little to do. On the other hand, if all processes are CPU-bound, the I/O waiting queue will almost always be empty, devices will go unused, and again the system will be unbalanced. The system with the best performance will thus have a combination of CPU-bound and I/O-bound processes. In modern operating systems, this is used to make sure that real-time processes get enough CPU time to finish their tasks.<ref name="Galvin">{{cite book
|author1=[[Abraham Silberschatz]] |author2=Peter Baer Galvin |author3=Greg Gagne
| title = Operating System Concepts
| volume = 9
| year= 2013
| publisher= John Wiley & Sons, Inc.
| isbn= 978-1-118-06333-0
}}</ref>

Long-term scheduling is also important in large-scale systems such as [[batch processing]] systems, [[computer cluster]]s, [[supercomputer]]s, and [[render farm]]s. For example, in [[concurrent computing|concurrent systems]], [[coscheduling]] of interacting processes is often required to prevent them from blocking due to waiting on each other. In these cases, special-purpose [[job scheduler]] software is typically used to assist these functions, in addition to any underlying admission scheduling support in the operating system.

Some operating systems only allow new tasks to be added if it is sure all real-time deadlines can still be met.
The specific heuristic algorithm used by an operating system to accept or reject new tasks is the ''admission control mechanism''.<ref>
Robert Kroeger (2004).
[https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.71.3977&rep=rep1&type=pdf "Admission Control for Independently-authored Realtime Applications"].
UWSpace.
http://hdl.handle.net/10012/1170 .
Section "2.6 Admission Control".
p. 33.
</ref>

===={{Anchor|MEDIUM-TERM}}Medium-term scheduling====
The ''medium-term scheduler'' temporarily removes processes from main memory and places them in secondary memory (such as a [[hard disk drive]]) or vice versa, which is commonly referred to as ''swapping out'' or ''swapping in'' (also incorrectly as ''[[paging]] out'' or ''paging in'').  The medium-term scheduler may decide to swap out a process that has not been active for some time, a process that has a low priority, a process that is [[page fault]]ing frequently, or a process that is taking up a large amount of memory in order to free up main memory for other processes, swapping the process back in later when more memory is available, or when the process has been unblocked and is no longer waiting for a resource.

In many systems today (those that support mapping virtual address space to secondary storage other than the swap file), the medium-term scheduler may actually perform the role of the long-term scheduler, by treating binaries as ''swapped-out processes'' upon their execution.  In this way, when a segment of the binary is required it can be swapped in on demand, or ''lazy loaded'', also called [[demand paging]].

===={{Anchor|SHORT-TERM}}Short-term scheduling====
The ''short-term scheduler'' (also known as the ''CPU scheduler'') decides which of the ready, in-memory processes is to be executed (allocated a CPU) after a clock [[interrupt]], an I/O interrupt, an operating [[system call]] or another form of [[Signal programming|signal]].  Thus the short-term scheduler makes scheduling decisions much more frequently than the long-term or mid-term schedulers{{snd}} A scheduling decision will at a minimum have to be made after every time slice, and these are very short.  This scheduler can be [[Preemption (computing)|preemptive]], implying that it is capable of forcibly removing processes from a CPU when it decides to allocate that CPU to another process, or non-preemptive (also known as ''voluntary'' or ''co-operative''), in which case the scheduler is unable to ''force'' processes off the CPU.

A preemptive scheduler relies upon a [[programmable interval timer]] which invokes an [[interrupt handler]] that runs in [[kernel mode]] and implements the scheduling function.

===={{Anchor|DISPATCH-LATENCY}}Dispatcher====
Another component that is involved in the CPU-scheduling function is the dispatcher, which is the module that gives control of the CPU to the process selected by the short-term scheduler. It receives control in kernel mode as the result of an interrupt or system call. The functions of a dispatcher involve the following:

* [[Context switch]]es, in which the dispatcher saves the [[State (computer science)|state]] (also known as [[Context (computing)|context]]) of the [[Process (computing)|process]] or [[Thread (computing)|thread]] that was previously running; the dispatcher then loads the initial or previously saved state of the new process.
* Switching to user mode.
* Jumping to the proper location in the user program to restart that program indicated by its new state.

The dispatcher should be as fast as possible since it is invoked during every process switch. During the context switches, the processor is virtually idle for a fraction of time, thus unnecessary context switches should be avoided. The time it takes for the dispatcher to stop one process and start another is known as the ''dispatch latency''.<ref name="Galvin" />{{rp|155}}