Operating System

[saurabh mishra]

Dear Members,
Can anyone please tell me, What is user level threads ?

 

[deankl]

Dear Members,
Can anyone please tell me, What is user level threads ?

There are two distinct models of thread controls, and they are user-level threads and kernel-level threads. The thread function library to implement user-level threads usually runs on top of the system in user mode. Thus, these threads within a process are invisible to the operating system. User-level threads have extremely low overhead, and can achieve high performance in computation. However, using the blocking system calls like read(), the entire process would block. Also, the scheduling control by the thread runtime system may cause some threads to gain exclusive access to the CPU and prevent other threads from obtaining the CPU. Finally, access to multiple processors is not guaranteed since the operating system is not aware of existence of these types of threads.
On the other hand, kernel-level threads will guarantee multiple processor access but the computing performance is lower than user-level threads due to load on the system. The synchronization and sharing resources among threads are still less expensive than multiple-process model, but more expensive than user-level threads. The thread function library available today is often implemented as a hybrid model, as having advantages from both user-level and kernel-level threads. The design consideration of thread packages today consists of how to minimize the system overhead while providing access to the multiple processors

 

[deankl]

User-Level Threads
Threads are the primary programming interface in multithreaded programming. User-level threads [User-level threads are named to distinguish them from kernel-level threads, which are the concern of systems programmers, only. Because this book is for application programmers, kernel-level threads are not discussed.] are handled in user space and avoid kernel context switching penalties. An application can have hundreds of threads and still not consume many kernel resources. How many kernel resources the application uses is largely determined by the application.

Threads are visible only from within the process, where they share all process resources like address space, open files, and so on. The following state is unique to each thread.

Thread ID

Register state (including PC and stack pointer)

Stack

Signal mask

Priority

Thread-private storage

Because threads share the process instructions and most of the process data, a change in shared data by one thread can be seen by the other threads in the process. When a thread needs to interact with other threads in the same process, it can do so without involving the operating environment.

By default, threads are very lightweight. But, to get more control over a thread (for instance, to control scheduling policy more), the application can bind the thread. When an application binds threads to execution resources, the threads become kernel resources (see "System Scope (Bound Threads)" for more information).

To summarize, user-level threads are:

Inexpensive to create because they do not need to create their own address space. They are bits of virtual memory that are allocated from your address space at run time.

Fast to synchronize because synchronization is done at the application level, not at the kernel level.

Easily managed by the threads library; either libpthread or libthread.

 

[GamezStar]

org yg sama ke ni?

 

[balung]

org yg sama ke ni?

apa yang sama?

 

[ems]

Isk..Google aje la bukan susah pn

 

[khairuls]

soalan macam takde kaitan dgn tajuk je ni