Operating System Concepts Threads A thread (or lightweight process) is a basic unit of CPU utilization; it consists of: Stack space PCB in the kernel A thread shares with its peer threads its: Text/Code section Data section collectively known as a task. A traditional or heavyweight process is equal to a task with one thread Operating System Concepts

Single and Multithreaded Processes Operating System Concepts

Operating System Concepts Threads (Cont.) In a multiple threaded task, while one server thread is blocked and waiting, a second thread in the same task can run. applications that require sharing a common buffer (i.e., producer-consumer) benefit from thread utilization. Threads provide a mechanism that allows sequential processes to make blocking system calls while also achieving parallelism. Types of threads: Kernel-supported threads. User-level threads; supported above the kernel, via a set of library calls at the user level. Anderson's threads: Like Kernel-supported threads, but sends events that influence user-level scheduling to the task, rather than interpret these events on its own. Operating System Concepts

Multithreading Models Many-to-One Many user-level threads are mapped to a single kernel thread. Used on systems that do not support kernel threads. Example: Project Andrew of CMU. One-to-One Each user-level thread is mapped to a kernel thread. Examples: WIndows95, Windows98 and OS/2. Many-to-Many Model Allows many user level threads to be mapped to many kernel threads. Allows the operating system to create a sufficient number of kernel threads. Hybrid approach, implements both user-level and kernel-supported threads. Examples: Solaris 2, Linux, WindowsNT, Windows2000. Operating System Concepts

Multithreading Models (Cont.) Many-to-one Many-to-many One-to-one Operating System Concepts

Threads Support in Solaris 2 Solaris 2 is a version of UNIX with a support of threads at the kernel and user levels. LWP – intermediate level between user-level threads and kernel-level threads. Resource needs of thread types: Thread of the kernel: Small data structure and a stack; thread switching does not require changing memory access information – relatively fast. LWP: PCB with register data, accounting and memory information; switching between LWPs is relatively slow. User-level thread: Only needs stack and program counter; no kernel involvement means fast switching. Kernel only sees the LWPs. Operating System Concepts

Operating System Concepts Solaris 2 Threads Operating System Concepts

Operating System Concepts Pthreads Posix 1003.1c defines a thread interface Called Pthreads (Posix Threads) Defines how threads should be created, managed, and destroyed Unix provides a pthreads library API to create and manage threads. No need to worry about the implementation details. Operating System Concepts

Operating System Concepts Creating Threads Prototype: int pthread_create(pthread_t *tid, const pthread_attr_t *tattr, void*(*start_routine)(void *), void *arg); tid: an unsigned long integer that indicates a threads id tattr: attributes of the thread – usually NULL start_routine: the name of the function the thread starts executing arg: the argument to be passed to the start routine – only one After this function has been executed, a new thread is created and is executing the function indicated by start_routine On success, pthread_create() returns 0. on error, it returns an error number. Operating System Concepts

Operating System Concepts Waiting for a Thread Prototype: int pthread_join(thread_t tid, void **status); tid: identification of the thread to wait for. status: the exit status of the terminating thread – can be NULL the thread that calls this function blocks its own execution until the thread indicated by tid terminates its execution finishes the function it started with. issues a pthread_exit() command. Operating System Concepts

Operating System Concepts Pthread Example #include <stdio.h> #include <pthread.h> void printMsg(char* msg) { printf(“%s\n”, msg); } int main(int argc, char** argv) { pthread_t thrdID; printf(“creating a new thread\n”); pthread_create(&thrdID, NULL, (void*)printMsg, argv[1]); printf(“created thread %d\n”, thrdID); pthread_join(thrdID, NULL); Operating System Concepts

Operating System Concepts Example (Cont.) thread 0 thread 1 create_thread() start of printMsg() end of printMsg() end of program Note: thread 0 is the function that contains main() – only one main() per program. Operating System Concepts

Operating System Concepts Exiting a Thread pthreads exist in user space and are seen by the kernel as a single process. if one thread issues and exit() system call, all the threads are terminated by the OS. if the main() function exits, all of the other threads are terminated as well. To have a thread exit, use pthread_exit() Prototype: void pthread_exit(void *status); status: the exit status of the thread is passed to the status variable in the pthread_join() function of the waiting thread. Operating System Concepts

Operating System Concepts Example Revisited #include <stdio.h> #include <pthread.h> void printMsg(char* msg) { int status = 0; printf(“%s\n”, msg); pthread_exit(&status); } int main(int argc, char** argv) { pthread_t thrdID; int *status = (int*)malloc(sizeof(int)); printf(“creating a new thread\n”); pthread_create(&thrdID, NULL, (void*)printMsg, argv[1]); printf(“created thread %d\n”, thrdID); pthread_join(thrdID, &status); printf(“Thread %d exited with status %d\n”, thrdID, *status); Operating System Concepts