Threads

Lecture 3

Washington
WASHINGTON UNIVERSITY IN ST LOUIS
 Some Definitions
• Parallelism: degree to which a multiprocessor
application achieves parallel execution
• Concurrency: Maximum parallelism an
application can achieve with unlimited
processors
• System Concurrency: kernel recognizes multiple
threads of control in a program
• User Concurrency: User space threads
(coroutines) to provide a natural programming
model for concurrent applications. Concurrency
not supported by system.

Fred Kuhns (12/09/21) CS523 – Operating Systems 2

 Process and Threads
• Process: encompasses
– set of threads (computational entities)
– collection of resources
• Thread: 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

Fred Kuhns (12/09/21) CS523 – Operating Systems 3

 Threads
• Effectiveness of parallel computing depends on
the performance of the primitives used to
express and control parallelism
• Threads separate the notion of execution from
the Process abstraction
• Useful for expressing the intrinsic concurrency
of a program regardless of resulting
performance
• Three types: User threads, kernel threads and
Light Weight Processes (LWP)

Fred Kuhns (12/09/21) CS523 – Operating Systems 4

 Threading 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

Fred Kuhns (12/09/21) CS523 – Operating Systems 5

 First Class threads (Psyche OS)
• Thread operations in user space:
– create, destroy, synch, context switch
• kernel threads implement a virtual processor
• Course grain in kernel - preemptive scheduling
• Communication between kernel and threads library
– shared data structures.
– Software interrupts (user upcalls or signals). Example, for
scheduling decisions and preemption warnings.
– Kernel scheduler interface - allows dissimilar thread packages
to coordinate.

Fred Kuhns (12/09/21) CS523 – Operating Systems 6

 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
• kernel is responsible for processor allocation =>
preemption by kernel.
• Thread package responsible for scheduling
threads on available processors (activations)

Fred Kuhns (12/09/21) CS523 – Operating Systems 7

 Support for Threading
• BSD:
– process model only. 4.4 BSD enhancements.
• Solaris:provides
– user threads, kernel threads and LWPs
• Mach: supports
– kernel threads and tasks. Thread libraries provide
semantics of user threads, LWPs and kernel threads.
• Digital UNIX: extends MACH to provide usual
UNIX semantics.
– Pthreads library.

Fred Kuhns (12/09/21) CS523 – Operating Systems 8

 Solaris Threads
• Supports:
– user threads (uthreads) via libthread and libpthread
– LWPs, acts as a virtual CPU for user threads
– kernel threads (kthread), every LWP is associated
with one kthread, however a kthread may not have an
LWP
• interrupts as threads

Fred Kuhns (12/09/21) CS523 – Operating Systems 9

 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

Fred Kuhns (12/09/21) CS523 – Operating Systems 10

 Solaris LWP
• Bound to a kthread
• LWP specific fields from proc are kept in
klwp_t (/usr/include/sys/klwp.h)
– user-level registers, system call params, resource
usage, pointer to kthread_t and proc_t
• klwp_t can be swapped with LWP
• LWP non-swappable info kept in kthread_t

Fred Kuhns (12/09/21) CS523 – Operating Systems 11

 Solaris LWP (cont)
• 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

Fred Kuhns (12/09/21) CS523 – Operating Systems 12

 Solaris User Threads
• Implemented in user libraries
• library provides synchronization and scheduling
facilities
• threads may be bound to LWPs
• unbound threads compete for available LWPs
• Manage thread specific info
– thread id, saved register state, user stack, signal
mask, priority*, thread local storage
• Solaris provides two libraries: libthread and
libpthread.
• Try man thread or man pthreads

Fred Kuhns (12/09/21) CS523 – Operating Systems 13

 Solaris Thread Data Structures

proc_t
p_tlist
kthread_t
t_procp
t_lwp
klwp_t
t_forw
lwp_thread
lwp_procp

Fred Kuhns (12/09/21) CS523 – Operating Systems 14

 Solaris: Processes, Threads and
LWPs
Process 1 Process 2

user
L L L L Int kthr

kernel ......
...

P P P
hardware

Fred Kuhns (12/09/21) CS523 – Operating Systems 15

 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

Fred Kuhns (12/09/21) CS523 – Operating Systems 16

 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

Fred Kuhns (12/09/21) CS523 – Operating Systems 17

 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 to one or more tasks

Fred Kuhns (12/09/21) CS523 – Operating Systems 18

 Mach c-thread Implementations
• Coroutine-based - multiples 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.

Fred Kuhns (12/09/21) CS523 – Operating Systems 19

 Digital UNIX
• Based on Mach 2.5 kernel
• Provides complete UNIX programmers
interface
• 4.3BSD code and ULTRIX code ported to Mach
– u-area replaced by utask and uthread
– proc structure retained

Fred Kuhns (12/09/21) CS523 – Operating Systems 20

 Digital UNIX threads
• Signals divided into synchronous and
asynchronous
• global signal mask
• each thread can define its own handlers for
synchronous signals
• global handlers for asynchronous signals

Fred Kuhns (12/09/21) CS523 – Operating Systems 21

 Pthreads library
• One Mach thread per pthread
• implements asynchronous I/O
– separate thread created for synchronous I/O which
in turn signals original thread
• library includes signal handling, scheduling
functions, and synchronization primitives.

Fred Kuhns (12/09/21) CS523 – Operating Systems 22

 Mach 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.

Fred Kuhns (12/09/21) CS523 – Operating Systems 23

 Threads in Windows NT
• Design driven by need to support a variety of
OS environments
• NT process implemented as an object
• executable process contains >= 1 thread
• process and thread objects have built in
synchronization capabilitiesS

Fred Kuhns (12/09/21) CS523 – Operating Systems 24

 NT Threads
• Support for kernel (system) threads
• Threads are scheduled by the kernel and thus
are similar to UNIX threads bound to an LWP
(kernel thread)
• fibers are threads which are not scheduled by
the kernel and thus are similar to unbound user
threads.

Fred Kuhns (12/09/21) CS523 – Operating Systems 25

 4.4 BSD UNIX
• Initial support for threads implemented but
not enabled in distribution
• Proc structure and u-area reorganized
• All threads have a unique ID
• How are the proc and u areas reorganized to
support threads?

Fred Kuhns (12/09/21) CS523 – Operating Systems 26