Operating Systems

Threads
Implementation

A. Frank - P. Weisberg
 Contents
• Multithreading Levels
• Multithreading Models
• Threading Issues

2 A. Frank - P. Weisberg
 Multithreading vs. Single threading
• Single threading: when the OS does not
recognize the concept of thread.
• Multithreading: when the OS supports multiple
threads of execution within a single process.
• MS-DOS supports a single user process and a
single thread.
• Older UNIXs supports multiple user processes
but only support one thread per process.
• Solaris and Windows NT support multiple
threads.
3 A. Frank - P. Weisberg
 Multithreading Levels
• Thread library provides programmer with API
for creating and managing threads.
• Three multithreading levels:
1) User-Level Threads (ULT)
• Library entirely in user space.
2) Kernel-Level Threads (KLT)
• Kernel-level library supported by the OS.
3) Hybrid ULT/KLT Approach

4 A. Frank - P. Weisberg
 User(-level) and Kernel(-level) Threads
• User(-level) threads – management by user-level threads
library.
• Three primary thread libraries:
– POSIX Pthreads
– Windows threads
– Java threads
• Kernel(-level) threads – supported by the Kernel.
• Examples – virtually all general purpose operating systems,
including:
– Windows
– Solaris
– Linux
– Tru64 UNIX
5 – Mac OS X
A. Frank - P. Weisberg
 User-Level Threads (ULT) )1
• Thread management done by
user-level threads library
• The kernel is not aware of
the existence of threads.
• All thread management is
done by the application by
using a thread library.
• Thread switching does not
require kernel mode privileges.
• Scheduling is application
6 specific. A. Frank - P. Weisberg
 Implementing Threads in User Space

7 A. Frank - P. Weisberg
 ULT Idea
• Thread management done by user-level threads
library.
• Threads library contains code for:
– creating and destroying threads.
– passing messages and data between threads.
– scheduling thread execution.
– saving and restoring thread contexts.
• Three primary thread libraries:
– POSIX Pthreads
– Win32 threads
– Java threads
8 A. Frank - P. Weisberg
 POSIX Pthreads
• A POSIX standard (IEEE 1003.1c) API for
thread creation and synchronization.
• May be provided either as ULT or KLT.
• API specifies behavior of the thread library,
implementation is up to development of the
library.
• Common in UNIX operating systems (Solaris,
Linux, Mac OS X).

9 A. Frank - P. Weisberg
 Some of the Pthreads function calls

10 A. Frank - P. Weisberg
 Kernel activity for ULTs
• The kernel is not aware of thread activity but it
is still managing process activity.
• When a thread makes a system call, the whole
task will be blocked.
• But for the thread library that thread is still in
the running state.
• So thread states are independent of process
states.

11 A. Frank - P. Weisberg
 Advantages and inconveniences of ULT
• Advantages • Inconveniences
– Thread switching – Most system calls are
does not involve the blocking and the kernel
kernel: no mode blocks processes. So all
switching. threads within the process
– Scheduling can be will be blocked.
application specific: – The kernel can only assign
choose the best processes to processors.
algorithm. Two threads within the
– ULTs can run on any same process cannot run
OS. Only needs a simultaneously on two
processors.
thread library. A. Frank - P. Weisberg
12
 Kernel-Level Threads (KLT) )2
• All thread management is
done by kernel.
• No thread library but an API
to the kernel thread facility.
• Kernel maintains context
information for the process
and the threads.
• Switching between threads
requires the kernel.
• Scheduling on a thread basis.
13 A. Frank - P. Weisberg
 Implementing Threads in the Kernel

14 A. Frank - P. Weisberg
 KLT Idea
• Threads supported by the Kernel.
• Examples:
– Windows 2000/XP
– OS/2
– Linux
– Solaris
– Tru64 UNIX
– Mac OS X
15 A. Frank - P. Weisberg
 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).
• This sharing of the address space allows the
cloned child task to behave much like a
separate thread.
16 A. Frank - P. Weisberg
 Advantages and inconveniences of KLT
• Advantages • Inconveniences
– the kernel can – thread switching
simultaneously within the same
schedule many threads process involves the
of the same process on kernel. We have 2
many processors. mode switches per
– blocking is done on a thread switch.
thread level. – this results in a
– kernel routines can be significant slow
multithreaded. down.
17 A. Frank - P. Weisberg
 ) s
( Thread operation latencies

Source: Anderson, T. et al, “Scheduler Activations: Effective

Kernel Support for the User-Level Management of
.Parallelism”, ACM TOCS, February 1992
18 A. Frank - P. Weisberg
 Hybrid ULT/KLT Approaches )3
• Thread creation done in the
user space.
• Bulk of scheduling and
synchronization of threads
done in the user space.
• The programmer may
adjust the number of KLTs.
• May combine the best of
both approaches.
• Example is Solaris prior to
19 version 9. A. Frank - P. Weisberg
 Hybrid Implementation (1)

Multiplexing user-level threads onto kernel-level

20 threads. A. Frank - P. Weisberg
 Hybrid Implementation (2)

21 A. Frank - P. Weisberg
 ULT, KLT and Combined Approaches

22 A. Frank - P. Weisberg
 Multithreading Models

• Many-to-One
• One-to-One
• Many-to-Many
• Two-level Model

23 A. Frank - P. Weisberg
 Relationship between Threads and Processes
Example Systems Description Threads:Processes

Traditional UNIX implementations Each thread of execution is a unique 1:1

process with its own address space and
.resources

Windows NT, Solaris, Linux, OS/2, A process defines an address space M:1
OS/390, MACH and dynamic resource ownership.
Multiple threads may be created and
.executed within that process

Ra (Clouds), Emerald A thread may migrate from one M:1

process environment to another. This
allows a thread to be easily moved
.among distinct systems

TRIX Combines attributes of M:1 and 1:M M:N

.cases

24 A. Frank - P. Weisberg
 Many-to-One Model (1)
• Many user-level threads mapped to single
kernel-level thread.

25 A. Frank - P. Weisberg
 Many-to-One Model (2)
• One thread blocking causes all to block.
• Multiple threads may not run in parallel on
multi-core system because only one may be in
kernel at a time.
• Few systems currently use this model.
• Examples:
– Solaris Green Threads
– GNU Portable Threads
26 A. Frank - P. Weisberg
 One-to-One Model (1)
• Each user-level thread maps to kernel-level thread.

27 A. Frank - P. Weisberg
 One-to-One Model (2)
• Creating a user-level thread creates a kernel
thread.
• More concurrency than many-to-one.
• Number of threads per process sometimes
restricted due to overhead.
• Examples
– Windows
– Linux
– Solaris 9 and later
28 A. Frank - P. Weisberg
 Many-to-Many Model (1)
Allows many user level threads to be mapped to many
kernel threads.

29 A. Frank - P. Weisberg
 Many-to-Many Model (2)

• Allows the operating system to create

a sufficient number of kernel threads.
• Solaris prior to version 9.
• Windows with the ThreadFiber
package.

30 A. Frank - P. Weisberg
 Two-level Model (1)
• Similar to Many-to-Many model, except that it allows
a user thread to be bound to kernel thread.

31 A. Frank - P. Weisberg
 Two-level Model (2)
• Examples:
– IRIX
– HP-UX
– Tru64 UNIX
– Solaris 8 and earlier

32 A. Frank - P. Weisberg
 Lightweight Process (LWP)

33 A. Frank - P. Weisberg
 Solaris 2 Threads

34 A. Frank - P. Weisberg
 Java Threads
• Java threads are managed by the JVM.
• Typically implemented using the threads model
provided by underlying OS.
• Java threads may be created by:
– Extending Thread class (at language-level)
– Implementing the Runnable interface

35 A. Frank - P. Weisberg
 Threading Issues
• Semantics of fork() and exec() system calls
– Does fork() duplicate only the calling thread or all
threads?
• Thread cancellation of target thread
– Asynchronous or deferred
• Signal handling
• Thread pools
• Thread-local storage
• Scheduler activations
36 A. Frank - P. Weisberg
 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.
37 A. Frank - P. Weisberg
 Signal Handling (1)
• Signals are used in UNIX systems to notify a process that a
particular event has occurred.
• A signal handler is used to process signals:
1. Signal is generated by particular event.
2. Signal is delivered to a process.
3. Signal is handled by one of two signal handlers:
1. default
2. user-defined
• Every signal has default handler that kernel runs when
handling signal:
 User-defined signal handler can override default.
 For single-threaded, signal delivered to process.

38
 Signal Handling (2)
• Where should a signal be delivered for multi-
threaded?
– 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.

39
 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.
40 A. Frank - P. Weisberg
 Thread-Local Storage
• Thread-local storage (TLS) 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).
• Different from local variables:
– Local variables visible only during single function
invocation.
– TLS visible across function invocations.
• Similar to static data:
– TLS is unique to each thread.
41
 Scheduler Activations
• Both M:M and Two-level models require
communication to maintain the appropriate number
of kernel threads allocated to the application/
• Typically use an intermediate data structure between
user and kernel threads – lightweight process (LWP):
– Appears to be a virtual processor on which process can
schedule user thread to run.
– Each LWP attached to kernel thread.
– How many LWPs to create?
• Scheduler activations provide upcalls –
a communication mechanism from the kernel to
the upcall handler in the thread library.
• This communication allows an application to
maintain the correct number kernel threads.

42
 Operating System Examples

• Windows Threads
• Linux Threads

43
 Windows Threads )1(
• Windows implements the Windows API – primary API for
Win 98, Win NT, Win 2000, Win XP, and Win 7.
• Implements the one-to-one mapping, kernel-level.
• Each thread contains:
– A thread id.
– Register set representing state of processor.
– Separate user and kernel stacks for when thread runs in user mode or
kernel mode.
– Private data storage area used by run-time libraries and dynamic link
libraries (DLLs).
• The register set, stacks, and private storage area are known as
the context of the thread.
44
 Windows Threads (2)
• The primary data structures of a thread include:
– ETHREAD (executive thread block) – includes
pointer to process to which thread belongs and to
KTHREAD, in kernel space.
– KTHREAD (kernel thread block) – scheduling and
synchronization info, kernel-mode stack, pointer to
TEB, in kernel space.
– TEB (thread environment block) – thread id, user-
mode stack, thread-local storage, in user space.

45
 Windows Threads Data Structures

46
 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).
– Flags control behavior.

• struct task_struct points to process data

47 structures (shared or unique).