Threads Cannot Be Implemented as a Library Review

Implementing threads

A thread library provides programmers with an API for creating and managing threads. Support for threads must exist provided either at the user level or by the kernel.

Kernel level threads are supported and managed direct by the operating organization.
User level threads are supported to a higher place the kernel in user space and are managed without kernel support.

Kernel level threads

Kernel level threads are supported and managed direct past the operating system.

The kernel knows nigh and manages all threads.
One process command block (PCP) per process.
One thread control block (TCB) per thread in the arrangement.
Provide system calls to create and manage threads from user infinite.

Advantages

The kernel has total cognition of all threads.
Scheduler may decide to give more CPU time to a procedure having a large numer of threads.
Proficient for applications that oftentimes block.

Disadvantages

Kernel manage and schedule all threads.
Significant overhead and increase in kernel complexity.
Kernel level threads are tedious and inefficient compared to user level threads.
Thread operations are hundreds of times slower compared to user-level threads.

User level threads

User level threads are supported above the kernel in user space and are managed without kernel support.

Threads managed entirely by the run-fourth dimension organization (user-level library).
Ideally, thread operations should exist as fast as a function call.
The kernel knows nothing near user-level threads and manage them as if they where unmarried-threaded processes.

Advantages

Can exist implemented on an Bone that does not suport kernel-level threads.
Does not require modifications of the Bone.
Unproblematic representation: PC, registers, stack and small thread command block all stored in the user-level process address space.
Simple direction: Creating, switching and synchronizing threads done in user-infinite without kernel intervention.
Fast and efficient: switching threads non much more than expensive than a part call.

Disadvantages

Not a perfect solution (a trade off).
Lack of coordination between the user-level thread manager and the kernel.
Bone may make poor decisions like:
- scheduling a procedure with idle threads
- blocking a procedure due to a blocking thread even though the process has other threads that can run
- giving a procedure equally a whole one time slice irrespective of whether the process has one or yard threads
- unschedule a procedure with a thread belongings a lock.
May crave communication betwixt the kernel and the user-level thread manager (scheduler activations) to overcome the to a higher place problems.

User-level thread models

In full general, user-level threads can be implemented using one of four models.

Many-to-one
One-to-1
Many-to-many
Two-level

All models maps user-level threads to kernel-level threads. A kernel thread is similar to a procedure in a non-threaded (single-threaded) organization. The kernel thread is the unit of execution that is scheduled by the kernel to execute on the CPU. The term virtual processor is frequently used instead of kernel thread.

Many-to-one

In the many-to-one model all user level threads execute on the aforementioned kernel thread. The process can merely run one user-level thread at a fourth dimension because there is but one kernel-level thread associated with the process.

The kernel has no cognition of user-level threads. From its perspective, a process is an opaque black box that occasionally makes arrangement calls.

One-to-ane

In the one-to-1 model every user-level thread execute on a separate kernel-level thread.

In this model the kernel must provide a system phone call for creating a new kernel thread.

Many-to-many

In the many-to-many model the process is allocated m number of kernel-level threads to execute n number of user-level thread.

Two-level

The two-level model is like to the many-to-many model simply likewise allows for sure user-level threads to be bound to a unmarried kernel-level thread.

Scheduler activations

In both the many-to-many model and the ii-level model at that place must exist some way for the kernel to communicate with the user level thread manager to maintain an appropriate number of kernel threads allocated to the process. This mechanism is called scheduler activations.

The kernel provides the awarding with a set of kernel threads (virtual processors), and then the awarding has complete control over what threads to run on each of the kernel threads (virtual processors). The number of kernel threads (virtual processors) in the set is controlled by the kernel, in response to the competing demands of unlike processes in the system.¹

The kernel notify the user-level thread manager of important kernel events using upcalls from the kernel to the user-level thread director. Examples of such events includes a thread making a blocking system call and the kernel allocating a new kernel thread to the process.¹

Example

Let'southward study an example of how scheduler activations tin can be used. The kernel has allocated one kernel thread (1) to a process with iii user-level threads (ii). The 3 user level threads take plough executing on the single kernel-level thread.

The executing thread makes a blocking system phone call (3) and the the kernel blocks the calling user-level thread and the kernel-level thread used to execute the user-level thread (4). Scheduler activation: the kernel decides to allocate a new kernel-level thread to the process (v). Upcall: the kernel notifies the user-level thread manager which user-level thread that is at present blocked and that a new kernel-level thread is available (6). The user-level thread manager motion the other threads to the new kernel thread and resumes one of the ready threads (7).

While one user-level thread is blocked (8) the other threads can take plough executing on the new kernel thread (nine).

User-level thread scheduling

Scheduling of the usea-level threads amid the bachelor kernel-level threads is washed past a thread scheduler implemented in user infinite. There are two main methods: cooperative and preemptive thread scheduling.

Cooperative scheduling of user-level threads

The cooperative model is like to multiprogramming where a process executes on the CPU until making a I/O asking. Cooperative user-level threads execute on the assigned kernel-level thread until they voluntarily requite back the kernel thread to the thread manager.

In the cooperative model, threads yield to each other, either explicitly (e.k., by calling a yield() provided by the user-level thread library) or implicitly (e.g., requesting a lock held by another thread). In the beneath figure a many-to-one organization with cooperative user-level threads is shown.

Preemptive scheduling of user-level threads

The preemptive model is like to multitasking (aka time sharing). Multitasking is a logical extension of multiprogramming where a timer is prepare to cause an interrupt at a regular fourth dimension interval and the running process is replaced if the task requests I/O or if the task is interrupted past the timer. This way, the running chore is given a time slice of execution than cannot be exceeded.

In the preemptive model, a timer is used to cause execution flow to jump to a primal dispatcher thread, which chooses the side by side thread to run. In the below figure a many-to-ane organization with preemptive user-level threads is shown.

Cooperative and preemptive (hybrid) scheduling of user-level threads

A hybrid model between cooperative and preemptive scheduling is also possible where a running thread may yield() or preempted past a timer.

jenkinslart1972.blogspot.com

Source: https://www.it.uu.se/education/course/homepage/os/vt18/module-4/implementing-threads/