Threads

1. Threads Fred Kuhns fredk@cse.wustl.edu Applied Research Laboratory, Department of Computer Science and Engineering, Washington University in St. Louis

2. Introduction to Threads Multithreaded Process Model Single-Threaded Process Model Thread Thread Thread Thread Control Block Thread Control Block Thread Control Block Process Control Block User Stack Process Control Block User Stack User Stack User Stack User Address Space Kernel Stack User Address Space Kernel Stack Kernel Stack Kernel Stack CS422 – Operating Systems Concepts

3. Threads • Dynamic object representing an execution path and computational state. • threads have their own computational state: PC, stack, user registers and private data • Remaining resources are shared amongst threads in a process • Effectiveness of parallel computing depends on the performanceof the primitives used to express and control parallelism • Useful for expressing the intrinsic concurrency of a program regardless of resulting performance • We will discuss three examples of threading: • User threads, • Kernel threads and • Scheduler Activations CS422 – Operating Systems Concepts

4. Common Thread Models • User level threads - user libraries implementation • Benefits: no kernel modifications, flexible and low cost • Drawbacks: thread may block entire process, no parallelism • Kernel level threads - kernel directly supports multiple threads of control in a process. • Benefits: scheduling/synchronization coordination, less overhead than process, suitable for parallel application • Drawbacks: more expensive than user-level threads, generality leads to greater overhead • Light-Weight Processes (LWP) Kernel supported user thread • LWP bound to kernel thread: a kernel thread may not be bound to an LWP • LWP is scheduled by kernel • User threads scheduled by library onto LWPs • Multiple LWPs per process CS422 – Operating Systems Concepts

5. P P P P P P Many-to-One One-to-One Many-to-Many Threading Models • User threads := Many-to-One • kernel threads := One-to-One • Mixed user and kernel := Many-to-Many CS422 – Operating Systems Concepts

6. User Level Threads • User level threads - supported by user level threads libraries • Examples • POSIX Pthreads, Mach C-threads, Solaris threads • Benefits: • no modifications required to kernel • flexible and low cost • Drawbacks: • can not block without blocking entire process • no parallelism (not recognized by kernel) CS422 – Operating Systems Concepts

7. Kernel Level Threads • Kernel level threads - directly supported by kernel, thread is the basic scheduling entity • Examples: • Windows 95/98/NT/2000, Solaris, Tru64 UNIX, BeOS, Linux • Benefits: • coordination between scheduling and synchronization • less overhead than a process • suitable for parallel application • Drawbacks: • more expensive than user-level threads • generality leads to greater overhead CS422 – Operating Systems Concepts

8. Threading Issues • fork and exec • should fork duplicate one, some or all threads • Cancellation – cancel the target thread, issues with freeing resources and inconsistent state • asynchronous cancellation – target is immediately canceled • deferred cancellation – target checks periodically. check at cancellation points • Signals: generation, posting and delivery • Every signal handled by a default or user-defined handler • Signal delivery: • to thread for which it may apply • to every thread in process • to certain threads • specifically designated thread (signal thread) • synchronous signals should go to thread causing the signal • what about asynchronous signals? • Solaris: deliver to a special thread which forward to first user created thread that has not blocked the signal. • Bounding the number of threads created in a dynamic environment • use thread pools • Al threads share some address space: • use of thread specific data CS422 – Operating Systems Concepts

9. Scheduler Activations • Attempt to combine benefits of both user and kernel threading support • blocking system call should not block whole process • user space library should make scheduling decisions • efficiency by avoiding unnecessary user, kernel mode switches. • Kernel assigns a set of virtual processors to each process. User library then schedules threads on these virtual processors. CS422 – Operating Systems Concepts

10. Scheduler Activations • An activation: • serves as execution context for running thread • notifies thread of kernel events (upcall) • space for kernel to save processor context of current user thread when stopped by kernel • Library schedules user threads on activations. • space for kernel to save processor context of current user thread when stopped by kernel • upall performed when one of the following occurs: • user thread performs blocking system call • blocked thread belonging to process, then its library is notified allowing it to either schedule a new thread or resume the preempted thread. • kernel is responsible for processor allocation => preemption by kernel. • Thread package responsible for scheduling threads on available processors (activations) CS422 – Operating Systems Concepts

11. Solaris Threads • Supports: • user threads (uthreads) via libthread and libpthread • LWPs, abstraction that acts as a virtual CPU for user threads. • LWP is bound to a kthread. • kernel threads (kthread), every LWP is associated with one kthread, however a kthread may not have an LWP • interrupts as threads CS422 – Operating Systems Concepts

12. Solaris kthreads • Fundamental scheduling/dispatching object • all kthreads share same virtual address space (the kernels) - cheap context switch • System threads - example STREAMS, callout • kthread_t, /usr/include/sys/thread.h • scheduling info, pointers for scheduler or sleep queues, pointer to klwp_t and proc_t CS422 – Operating Systems Concepts

13. Solaris LWP • Kernel provided mechanism to allow for both user and kernel thread implementation on one platform. • Bound to akthread • LWP data (see /usr/include/sys/klwp.h) • user-level registers, system call params, resource usage, pointer to kthread_t and proc_t • All LWPs in a process share: • signal handlers • Each may have its own • signal mask • alternate stack for signal handling • No global name space for LWPs CS422 – Operating Systems Concepts

14. L L L L ... ... ... P P P Solaris Threading Model (Combined) Process 2 Process 1 user Int kthr kernel hardware CS422 – Operating Systems Concepts

15. Solaris User Level Threads Stop Wakeup Runnable Continue Stop Stopped Sleeping Preempt Dispatch Stop Active Sleep CS422 – Operating Systems Concepts

16. Solaris Lightweight Processes Timeslice or Preempt Stop Running Dispatch Wakeup Blocking System Call Runnable Stopped Continue Wakeup Stop Blocked CS422 – Operating Systems Concepts

17. Solaris Interrupts • One system wide clock kthread • pool of 9 partially initialized kthreads per CPU for interrupts • interrupt thread can block • interrupted thread is pinned to the CPU CS422 – Operating Systems Concepts

18. Solaris Signals and Fork • Divided into Traps (synchronous) and interrupts (asynchronous) • each thread has its own signal mask, global set of signal handlers • Each LWP can specify alternate stack • fork replicates all LWPs • fork1 only the invoking LWP/thread CS422 – Operating Systems Concepts

19. Mach • Two abstractions: • Task - static object, address space and system resources called port rights. • Thread - fundamental execution unit and runs in context of a task. • Zero or more threads per task, • kernel schedulable • kernel stack • computational state • Processor sets - available processors divided into non-intersecting sets. • permits dedicating processor sets tasks • Mach C-Threads: • Coroutine-based - multiple user threads onto a single-threaded task • Thread-based - one-to-one mapping from c-threads to Mach threads. Default. • Task-based - One Mach Task per c-thread. CS422 – Operating Systems Concepts

20. Continuations • Address problem of excessive kernel stack memory requirements • process model versus interrupt model • one per process kernel stack versus a per thread kernel stack • Thread is first responsible for saving any required state (the thread structure allows up to 28 bytes) • indicate a function to be invoked when unblocked (the continuation function) • Advantage: stack can be transferred between threads eliminating copy overhead. CS422 – Operating Systems Concepts