1. Chapter 4: Threads
羅習五

2. Chapter 4: Threads Motivation and Overview Multithreading Models
Threading Issues
Examples
Pthreads
Windows XP Threads
Linux Threads
Java Threads

3. Motivation - the overhead of using processes
Creating a new process needs many system resources
Process control block (TCB)
xxx Control Block…
Memory …

4. Motivation - the overhead of using processes
The overhead of context-switch
+ store/restore the register file (~1kB)
+ TLB miss (~1kB)
+ CPU cache miss (~1MB)
CPU
(core)
Reg.
1 cycle
L1$
5 cycles
MMU (+TLB)
L2$
25 cycles

5. Single and Multithreaded Processes

6. Benefits Responsiveness Resource Sharing Economy
Several threads can share a memory space
Economy
Creating a thread vs. creating a process
The overhead of context switch
Utilization of Multithreaded Architectures
SMT (simultaneously multithreading)
CMP (chip-multiprocessor)
SMP (symmetric multiprocessor)

7. Multithreading Models
Many-to-One
One-to-One
Many-to-Many

8. Many-to-one Model
Many user-level threads mapped to single kernel thread
Thread management done by user-level threads library
All threads of a process will block if a thread makes a blocking system call
Examples:
Solaris Green Threads
GNU Portable Threads

9. Green threads
Green threads are threads that are scheduled by a user space scheduler instead of natively by the underlying OS.
On a multi-core processor, green thread implementations can not assign work to multiple processors.
Poor performance

10. Many-to-One Model

11. One-to-One Each user-level thread maps to a kernel thread Pros: Cons:
Threads are running when a thread makes a blocking system call
Threads of a process can run in parallel on a multithreaded machine
Cons:
The overhead of creating a new thread
Systems that implement one-to-one model
Linux
Solaris 9 and later
Windows NT

12. One-to-one Model

13. The Linux Task Control Block
state
CPU registers
memory
Accounting
Open files

14. One-to-one Model (Example: Linux)
Task 1
Task 2
Task 3
User space
Kernel space
PCB 1
PCB 2
PCB 3
Memory control block 1
Memory control block 3

15. Linux Threads To the Linux kernel, there is no concept of a thread.
Linux implements all threads as standard processes.
To create a new thread
clone(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
To create a new process
clone(SIGCHLD);

16. 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
Solaris prior to version 9
Windows NT/2000 with the ThreadFiber package

17. Many-to-Many Model
LWP

18. Two-level Model
Similar to many-to-many, except that it allows a user thread to be bound to a kernel thread
Examples
IRIX
HP-UX
Tru64 UNIX
Solaris 8 and earlier

19. Two-level Model (~Solaris 8)
LWP
LWP

20. Sun OS
Definition:
Kernel threads
The object that gets scheduled and executed on a processor.
User threads
The user-level (non-kernel) thread state maintained within a user process.
Process
The executable form of a program; the execution environment for a user program.
Lightweight process (LWP)
The kernel-visible execution context for a user thread.
Beginning in Solaris 9, there is a one-to-one relationship between user threads, LWPs, and kernel threads.

21. Sun OS (Solaris 9 and 10)

22. M:N model vs. 1:1 model
The 1:1 model offers several benefits over the M:N model
Improved performance, scalability, and reliability
Reliable signal behavior
Improved adaptive mutex lock implementation
User-level sleep queues for synchronization objects

23. Threading Issues Semantics of fork() and exec() system calls
Thread cancellation
Signal handling
Thread pools
Thread specific data
Scheduler activations

24. Threading Issues fork() and exec() Cancellation
Does fork() duplicate only the calling thread or all threads?
exec() will replace the entire process including all threads
Cancellation
Asynchronous cancellation
Synchronous cancellation

25. Threading Issues Signal handling
Deliver the signal to the thread to which the signal applies
Example: divided by zero (exception)
Deliver the signal to every thread in the process
Example: ctrl + c
Deliver the signal to certain threads in the process
pthread_kill()
Assign a specific thread to receive all signals for the process

26. Threading Issues Thread pools Thread-specific data
Create a number of threads in a pool where they await work
Advantages:
Faster
A thread pool limit the number of threads of an application
Thread-specific data
Win32, Pthreads and Java support this feature.

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

28. Examples

29. Pthreads
A POSIX standard (IEEE c) API for thread creation and synchronization
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)

30. OpenMP (Open Multi-Processing)
OpenMP is an API that supports shared memory multiprocessing programming in C/C++ and Fortran.
Version 3.0 is the current version of the OpenMP specifications.
the most interesting new features in 3.0 is he concept of tasks.
gcc 4.4

31. OpenMP Parallelism

32. History of OpenMP & gcc C/C++ spec 1.0, Oct '98
C/C++ spec 2.0, Mar '02
C/C++ spec 2.5, May '05
gcc 4.2
C/C++ spec 3.0, May, '08
+the concept of tasks and the task construct (recursive functions)
gcc 4.4
The current stable version is gcc 4.4

33. Windows XP Threads Implements the one-to-one mapping
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)

34. 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)

35. Java Threads Java threads are managed by the JVM
Java threads may be created by:
Extending Thread class
Implementing the Runnable interface

36. Java Thread States

37. 參考、引用文獻 Operating system principles, 7th edition
Linux kernel development, 2nd edition
Understanding the Linux Kernel, 3rd edition
Solaris™ Internals: Solaris 10 and OpenSolaris Kernel Architecture, 2nd edition
Wikipedia