UNIX for Dummies Questions & Answers

Almost, when you are running a user program your threads may still be kernel threads, as the kernel will do the scheduling and decide when to switch between them.

A user thread is implemented in library outside of the kernel, the kernel still thinks the process is a single threaded one, so the library itself has to do the context switching gymnastics.

But in a user program which uses kernel threads, the kernel knows that the user process contains a number of threads and will do the appropriate scheduling between them.

Note that in order to use an SMP machine (multi CPU etc) efficiently you need kernel threads. If not, then the kernel only thinks your process has one thread and hence all that processes scheduling will occur on one CPU even if the other CPU is idle. With kernel threads, the kernel can run different slices of different threads on different CPUs.

Code:

1. Kernel threads, implemented by the kernel, synchronisation is performed by the kernel.

Does the word ' implementation ' means the library ?
I don't really understand what does it mean here.

Or is the scheduling that is taken care by the kernel ?

Could you please explain that ?

( I have been waiting / expecting these kind of threads in the forum ! )

I guess so... Threads, as I know, can be implemented either in the user space by the user using some libraries or in the kernel by the kernel using some other libraries (I have a doubt with "some other libraries" though)... For example, as porter actually told me once, if one is using pthreads, they need not have to bother what is happening... Anyways, even I'll wait for an answer but I got something that might actually add to this discussion:

Kernel-level implementation examples

* Light Weight Kernel Threads in various BSDs
* M:N threading (in BSDs)
* Native POSIX Thread Library for Linux, an implementation of the POSIX Threads (pthreads) standard
* Apple Multiprocessing Services version 2.0 and later, uses the built-in nanokernel in Mac OS 8.6 and later which was modified to support it.

User-level implementation examples

* GNU Portable Threads
* FSU Pthreads
* Apple Inc.'s Thread Manager
* REALbasic (includes an API for cooperative threading)
* Netscape Portable Runtime (includes a user-space fibers implementation)

It means the code that performs the functions, it implements the functions.

Yes.

Kernel Threads - the code that implements these runs in the kernel, only the kernel has the ability to do the synchronisation (eg see SMP etc).

User theads - the user process does the synchronisation because the kernel knows nothing about them, there is nobody else.

For instance "Xavier Leroy's LinuxThreads" uses Linux's "clone()" call to make a kernel task that shares the same memory as the current process, so the library provides the API, but the actual thread is a fully fledged kernel task, the kernel does the scheduling and synchronisation.

GNU's portable threads on the other hand uses signals, setjmp/longjmp, contexts or other sleight of hand in order to create a new stack and execution environment in the same process, as the kernel knows nothing about these, all the scheduling and thread switch has to be done by similar sleight of hand setjmp/longjmp, etc.

So which mechanism can take advantage of multiple CPUs and put different threads on different CPUs?