Thread

A basic unit of CPU utilization. It comprises a thread ID, a program counter, a register set, and a stack. It is a single sequential flow of control within a program It shares with other threads belonging to the same process its code section, data section, and other OS resources, such as open files and signals A traditional (or heavyweight) process has a single thread of control If a process has multiple threads of control, it can perform more than one task at a time. Threads are a way for a program to split itself into two or more simultaneously running tasks. That is the real excitement surrounding threads

Single and Multithreaded Processes

Thread Examples A word processor may have a thread for displaying graphics, another thread for responding to keystrokes from the user, and a third thread for performing spelling and grammar checking in the background

Thread Example: Multithreaded Server Architecture

Single-Threaded Example Imagine the following C program main() { ComputePI( “ pi.txt ” ); PrintClassList( “ clist.text ” ); } What is the behavior here?

Use of Threads Version of program with Threads main() { CreateThread(ComputePI( “ pi.txt ” )); CreateThread(PrintClassList( “ clist.text ” )); } What does “ CreateThread ” do? – Start independent thread running given procedure What is the behavior here? – This should behave as if there are two separate CPUs CPU1CPU2CPU1CPU2 Time CPU1CPU2

Memory Footprint of Two-Thread Example If we stopped this program and examined it with a debugger, we would see – Two sets of CPU registers – Two sets of Stacks Code Global Data Heap Stack 1 Stack 2 Address Space

Per Thread State Each Thread has a Thread Control Block (TCB) – Execution State: CPU registers, program counter, pointer to stack – Scheduling info: State (more later), priority, CPU time – Accounting Info – Various Pointers (for implementing scheduling queues) – Pointer to enclosing process (PCB) – Etc

Benefits Responsiveness Resource Sharing Economy Utilization of MP Architectures

Multithreading Models Support for threads may be provided either at the user level, for user threads (supported above the kernel and managed without kernel support), or by the kernel, for kernel threads (supported and managed directly by the OS) Three common ways of establishing relationship between user and kernel threads – Many-to-One – One-to-One – Many-to-Many

User Threads Thread management done by user-level threads library Three primary thread libraries: – POSIX Pthreads – Win32 threads – Java threads

Kernel Threads Supported by the Kernel Examples –Windows XP/2000 –Solaris –Linux –Tru64 UNIX –Mac OS X

Many-to-One (User-Level Threads) Many user-level threads mapped to single kernel thread

Many-to-One (User-Level Threads) Basically, the kernel is not aware of the existence of threads. Thread switching does not require kernel mode privileges and scheduling is application specific. Thread management is done by the thread library in user space, so it is efficient Just as a uniprocessor provides the illusion of parallelism by multiplexing multiple processes on a single CPU, user-level threads packages provide the illusion of parallelism by multiplexing multiple user threads on a single kernel thread

Many-to-One (User-Level Threads) Since there is only one kernel thread, if a user thread executes a blocking system call, the entire process blocks, since no other user thread can execute until the kernel thread (which is blocked in the system call) becomes available Multithreaded programs will run no faster on multiprocessors than they run on uniprocessors. The single kernel thread acts as a bottleneck, preventing optimal use of the multiprocessor

Many-to-One (User-Level Threads) Advantages – Thread switching does not involve kernel  no mode switching – Scheduling can be application specific  choose best algorithm – ULTs can run on any OS  only needs a thread library Disadvantages – Most system calls are blocking and the kernel blocks processes  all threads within the process will be blocked – Kernel can only assign processes to processors  threads within same process cannot run simultaneously on processors

One-to-One (Kernel-Level Threads) Each user-level thread maps to kernel thread

One-to-One (Kernel-Level Threads) Because each kernel thread is actually a different kernel-schedulable entity, multiple threads can run concurrently on different processors – Can achieve significant speedups when migrated from uniprocessors to multiprocessors Unlike the many-to-one model, threads blocking in the kernel do not impede process progress under the one-to-one model. When one user thread and its kernel thread block, the other user threads can continue to execute since their kernel threads are unaffected The only drawback is that creating a user thread requires creating the corresponding kernel thread – Overhead of creating kernel threads can burden the performance of the application

Many-to-Many Model Allows many user-level threads to be mapped to many kernel threads Idea is to combine the best of both approaches

Solaris combines both ULT and KLT

Thread Libraries A thread library provides the programmer with an API for creating and managing threads Two primary ways of implementing a thread library – Provide the library entirely in user space with no kernel support. All code and data structures for the library exist in user space. Invoking a function in the library results in a local function in user space and not a system call – Implement kernel-level library supported directly by the OS. In this case, code and data structures for the library exist in kernel space. Invoking a function results in a system call to the kernel – Three main thread libraries in use today: (1) POSIX Pthreads, (2) Win32, and (3) Java

Pthreads Example: Design a multithreaded program that performs the following summation in a separate thread N sum =  i i = 0

Pthreads #include int sum; //this data is shared by the thread(s) void *runner(void *param); // the thread main(int argc, char* argv[]) { pthread_t tid; // the thread identifier pthread_create(&tid,NULL,runner,argv[1]); // create thread pthread_join(tid,NULL); // now wait for the thread to exit printf("sum = %d\n",sum); }

Pthreads void *runner(void *param) { int upper = atoi(param); int i; sum = 0; if (upper > 0) { for (i = 1; i <= upper; i++) sum += i; } pthread_exit(0); }

Threading Issues Semantics of fork() and exec() system calls Thread cancellation of target thread –Asynchronous or deferred Signal handling Thread pools Thread-specific data Scheduler activations

Thread Cancellation Terminating a thread before it has finished Two general approaches: –Asynchronous cancellation terminates the target thread immediately –Deferred cancellation allows the target thread to periodically check if it should be cancelled

Semantics of fork() and exec() If one thread in a program calls fork(), does the new process duplicate only the calling thread or all threads? – Some UNIX systems provide two versions of fork() – One duplicates all threads – The other duplicates only the thread that invoked fork() The exec() system call typically works in the same way as described before. That is, if a thread invokes exec(), the program specified in the parameter to exec() will replace the entire process – including all threads

Signal Handling Signals are used in UNIX systems to notify a process that a particular event has occurred A signal handler is used to process signals  Signal is generated by particular event  Signal is delivered to a process  Signal is handled Options: –Deliver the signal to the thread to which the signal applies –Deliver the signal to every thread in the process –Deliver the signal to certain threads in the process –Assign a specific thread to receive all signals for the process

Thread Pools Create a number of threads in a pool where they await work Advantages: –Usually slightly faster to service a request with an existing thread than create a new thread –Allows the number of threads in the application(s) to be bound to the size of the pool

Thread Specific Data Allows each thread to have its own copy of data Useful when you do not have control over the thread creation process (i.e., when using a thread pool)

Scheduler Activations Both M:M and Two-level models require communication to maintain the appropriate number of kernel threads allocated to the application Scheduler activations provide upcalls - a communication mechanism from the kernel to the thread library This communication allows an application to maintain the correct number kernel threads

Operating System Examples Windows XP Threads Linux Thread

Windows XP Threads

Linux Threads

Windows XP Threads Implements the one-to-one mapping, kernel-level Each thread contains –A thread id –Register set –Separate user and kernel stacks –Private data storage area The register set, stacks, and private storage area are known as the context of the threads The primary data structures of a thread include: –ETHREAD (executive thread block) –KTHREAD (kernel thread block) –TEB (thread environment block)

Linux Threads Linux refers to them as tasks rather than threads Thread creation is done through clone() system call clone() allows a child task to share the address space of the parent task (process)