Question

Suppose as an operating system designer you must choose between using either a Many-to-One or One-to-One Multithreading model between user and kernel threads. Describe what factors you should consider before choosing one or the other.

Answer 1

Many to One Model

• In the many to one model, many user-level threads are all mapped onto a single kernel thread.
• Thread management is handled by the thread library in user space, which is efficient in nature.
• In this model when a user thread makes a blocking system call entire process blocks. As we have only one kernel thread and only one user thread can access kernel at a time, so multiple threads are not able access multiprocessor at the same time.
• Thread management is handled by the thread library in user space, which is very efficient.
• However, if a blocking system call is made, then the entire process blocks, even if the other user threads would otherwise be able to continue.
• Because a single kernel thread can operate only on a single CPU, the many-to-one model does not allow individual processes to be split across multiple CPUs
• Green threads for Solaris and GNU Portable Threads implement the many-to-one model in the past, but few systems continue to do so today.

                                      

One to One Model

• The one to one model creates a separate kernel thread to handle each and every user thread.
• Most implementations of this model place a limit on how many threads can be created.
• Linux and Windows from 95 to XP implement the one-to-one model for threads.     
• In this model multiple thread can run on multiple processor. Problem with this model is that creating a user thread requires the corresponding kernel thread.   
• One-to-one model overcomes the problems listed above involving blocking system calls and the splitting of processes across multiple CPUs.
• However the overhead of managing the one-to-one model is more significant, involving more overhead and slowing down the system.
• Most implementations of this model place a limit on how many threads can be created.
•           
• 

By this we can say that many -to-one thread is more efficient than one-to-one because in one-to-one only one task can be performed at a time which ultimately result in slow processing.

But in many-to-one the process can't be run in parallel and so that it can't use the entire multiprocessor system,but it can generate multiple threads to perform a single task.