under what circumstances is better to use kernel-level threads than user-level threads?

A task is accomplished on the execution of a plan, which results in a process. Every task incorporates i or many sub tasks, whereas these sub tasks are carried out as functions within a program by the threads. The operating system (kernel) is unaware of the threads in the user infinite.

In that location are two types of threads, User level threads (ULT) and Kernel level threads (KLT).

1. User Level Threads :
   Threads in the user space designed by the application programmer using a thread library to perform unique subtask.
   
2. Kernel Level Threads :
   Threads in the kernel space designed by the bone developer to perform unique functions of OS. Similar to a interrupt handler.
   

There exist a potent a human relationship betwixt user level threads and kernel level threads.

Dependencies between ULT and KLT :

1. Use of Thread Library :
   Thread library acts as an interface for the application programmer to create number of threads (co-ordinate to the number of subtasks) and to manage those threads. This API for a process can exist implemented in kernel space or user space. In real-fourth dimension application, the necessary thread library is implemented in user space. This reduces the system call to kernel whenever the application is in need of thread creation, scheduling or thread direction activities. Thus, the thread creation is faster as information technology requires simply role calls inside the process. The user address space for each thread is allocated at run-time. Overall it reduces diverse interface and architectural overheads as all these functions are contained of kernel support.
2. Synchronization :
   The subtasks (functions) within each task (procedure) can be executed concurrently or parallelly depending on the application. In that case, unmarried-threaded process is non suitable. There evokes multithreaded procedure. A unique subtask is allocated to every thread inside the process. These threads may use the same data section or different information section. Typically, threads within the aforementioned process will share the lawmaking section, data section, accost space, open files etc.

When subtasks are meantime performed past sharing the code department, it may outcome in information inconsistency. Ultimately, requires suitable synchronization techniques to maintain the control flow to access the shared information (critical section).

In a multithreaded process, synchronization adopted using four dissimilar models :

1. Mutex Locks – This allows only one thread at a time to access the shared resources.
   
2. Read/Write Locks – This allows exclusive writes and concurrent read of a shared resources.
   
3. Counting Semaphore – This count refers to the number of shared resource that can be accessed simultaneously at a time. Once the count limit is reached, the remaining threads are blocked.
   
4. Condition Variables – This blocks the thread until the condition satisfies(Busy Waiting).
   All these synchronization models are carried out within each process using thread library. The retentivity infinite for the lock variables is allocated in the user address infinite. Thus, requires no kernel intervention.

one. Scheduling :
The application developer during the thread cosmos sets the priority and scheduling policy of each ULT thread using the thread library. On the execution of plan, based on the defined attributes the scheduling takes place by the thread library. In this instance, the arrangement scheduler has no control over thread scheduling as the kernel is unaware of the ULT threads.

2. Context Switching :
Switching from one ULT thread to other ULT thread is faster within the same process, as each thread has its own unique thread control cake, registers, stack. Thus, registers are saved and restored. Does not crave any change of address infinite. Entire switching takes place within the user accost space under the control of thread library.

3. Asynchronous I/O :
Subsequently an I/O request ULT threads remains in blocked country, until it receives the acknowledgment(ack) from the receiver. Although it follows asynchronous I/O, it creates a synchronous environment to the application user. This is because the thread library itself schedules an other ULT to execute until the blocked thread sends sigpoll every bit an ack to the process thread library. Merely then the thread library, reschedules the blocked thread.

For example, consider a program to re-create the content(read) from i file and to paste(write) in the other file. Additionaly, a popular-up that displays the percentage of progress completion.

This procedure contains iii subtasks each allocated to a ULT,

• Thread A – Read the content from source file. Store in a global variable Ten within the procedure address space.
  
• Thread B – Read the global variable X. Write in the destination file.
  
• Thread C – Brandish the percentage of progress done in a graphical representation.
  

Here, the application developer will schedule the multiple flow of control within a program using the thread library.

Social club of execution: Begins with Thread A, Then thread B and so thread C.
Thread A and Thread B shares the global variable X. Merely when after thread A writes on X, thread B can read X. In that case, synchronization is to be adopted on the shared variable to avoid thread B from reading onetime data.Context switching from thread A to Thread B and then Thread C takes identify within the procedure address infinite. Each thread saves and restores the registers in its ain thread control block (TCB). Thread C remains in blocked land, until thread B starts its outset write operation on the destination file. This is the reason behind, the graphical indication of 100% pops-up a few seconds after although process completion.

Dependency between ULT and KLT :
The i and but major dependency between KLT and ULT arise when an ULT is in need of the Kernel resources. Every ULT thread is associated to a virtual processor called Calorie-free-weight process. This is created and bined to ULT by the thread library co-ordinate to the application need. Whenever a arrangement call invoked, a kernel level thread is created and scheduled to the LWPs by the system scheduler. These KLT are scheduled to access the kernel resources past the system scheduler which is unaware of the ULT. Whereas the KLT is aware of each ULT associated to information technology via LWPs.

What if the human relationship does not exist?
If there is no clan between KLT and ULT, then according to kernel every process is a unmarried-threaded process. In that case,

1. The organisation scheduler may schedule a process with threads that are of less priority or idle threads. This leads to starvation of high-prioritized thread, which in turn reduces the efficiency of the system.
   
2. When a single thread gets blocked, the unabridged procedure gets blocked. Then the CPU utilization even in a multicore system volition become much less. Though there may be executable threads, kernel considers every process every bit a single threaded process and allocates simply 1 core at a time.
   
3. Arrangement scheduler may provide a single time slice irrespective of the number of threads inside a process. A single threaded procedure and a process with 1000 threads provided with same fourth dimension slice will make arrangement more inefficient.
   

robertsvengland.blogspot.com

Source: https://www.geeksforgeeks.org/relationship-between-user-level-thread-and-kernel-level-thread/

Share this post