1. Chapter 4: Threads

2. Chapter 4: Threads Topics: Overview Multithreading Models
Thread Libraries
Threading Issues
Operating System Examples
Windows XP Threads
Linux Threads
Objectives:
To introduce the notion of a thread — a fundamental unit of CPU utilization that forms the basis of multithreaded computer systems
To discuss the APIs for the Pthreads, Win32, and Java thread libraries
To examine issues related to multithreaded programming

3. Threads Motivation Threads run within application
Multiple tasks with the application can be implemented by separate threads
Update display
Fetch data
Spell checking
Answer a network request
Process creation is heavy-weight while thread creation is light-weight
Can simplify code, increase efficiency
Kernels are generally multithreaded

4. Benefits
Responsiveness
Resource Sharing
Economy
Scalability

5. Question
Which pieces of information from a process can be shared by all threads of a process and which ones need to be unique?
Process info:
State
Program counter
Registers
Open files
Stack
Text section (code)
Data

6. Single and Multithreaded Processes

7. Multithreaded Server Architecture

8. Multicore Programming
Multicore systems putting pressure on programmers, challenges include:
Dividing activities
Balance
Data splitting
Data dependency
Testing and debugging

9. Concurrency
Single-core System
Multicore System

10. Multithreading Models

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

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

13. Multithreading Models
Many-to-One
One-to-One
Many-to-Many
Two-level
Main considerations:
Limited number of threads?
Concurrency: What if a thread makes a blocking system call?
Allows for parallel execution on multiprocessor machines?

14. Many-to-One Many user-level threads mapped to single kernel thread
Examples:
Solaris Green Threads
GNU Portable Threads
Only 1 thread can access the kernel at a time

15. One-to-One Each user-level thread maps to kernel thread
Examples: Windows NT/XP/2000, Linux, Solaris 9 and later

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

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

18. Thread Libraries

19. Thread Libraries
Thread library provides programmer with API for creating and managing threads
Two primary ways of implementing
Library entirely in user space
Kernel-level library supported by the OS

20. Pthreads May be provided either as user-level or kernel-level
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
Policy vs. mechanism
Common in UNIX operating systems (Solaris, Linux, Mac OS X & in Windows via shareware implementations)

21. Examples
Pthreads
Win32 API
Java

22. 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
Implementing the Runnable interface

23. Tuesday, January 31, 2012
lab1 – graded copies pushed out 4:00 PM
lab2 – due tomorrow
hwk04 – due Thursday
“What is Google Chrome OS?”

24. Threading Issues

25. Threading Issues Scheduler activations
Semantics of fork() and exec() system calls
Thread cancellation of target thread
Asynchronous or deferred
Signal handling
Synchronous and asynchronous
Thread pools
Thread-specific data
Create Facility needed for data private to thread

26. Scheduler Activations
Both many-to-one and many-to-many 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

27. Lightweight Processes
Virtual processor (LWP) between thread library (user thread(s)) and kernel
Not present in all OSes
In some contexts, LWP refers to the kernel thread

28. Tracking Threads on ranger
ps –eLf command:
$ ps -eLf | head -n 1; ps -eLf | grep $USER
UID PID PPID LWP C NLWP STIME TTY TIME CMD
hcarroll :23 pts/ :00:00 ./pthreadsExample
hcarroll :23 pts/ :00:31 ./pthreadsExample
hcarroll :24 pts/ :00:00 ps -eLf
hcarroll :24 pts/ :00:00 grep hcarroll
root :21 ? :00:00 sshd: hcarroll [priv]
hcarroll :21 ? :00:00 sshd:
hcarroll :21 pts/ :00:00 -bash
hcarroll :45 pts/ :00:00 emacs

29. Semantics of fork() and exec()
What does fork() do?
What does exec() do?
Does fork() duplicate only the calling thread or all threads for that process?
Discuss with your neighbor(s) how can you test this?
Q: How can we learn more about these commands?
A: “man exec -S 3”

30. Multi-processes with Multi-threads
ps -eLf | head -n 1; ps -eLf | grep $USER

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

32. 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 for multi-threaded processes:
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

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

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

35. Operating System Examples

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

37. Windows XP Threads Data Structures

38. Linux Threads fork() and clone() system calls
Doesn’t distinguish between process and thread
Uses term task rather than thread
clone() takes options to determine sharing on process create
struct task_struct points to process data structures (shared or unique)

39. Recap
Provide 2 programming example in which multithreading provides better performance than a single-threaded solution.
What are at least 2 differences between a kernel thread and a user thread?
What is the difference between creating and managing processes and threads (e.g., what do they share)?
Which of the following components of program state are shared across threads in a multithreaded process? (Exercise 4.10)
Register values, Heap memory, Global variables, Stack memory
Consider a multiprocessor system and a multithreaded program written using the many-to-many threading model. Let the number of user-level threads in the program be more than the number of processors in the system. Discuss the performance implications of the following scenarios: (Exercise 4.14)
Number of kernel threads allocated to the program is less than the number of cores.
Number of kernel threads allocated to the program is equal to the number of cores.
Number of kernel threads allocated to the program is greater than the number of cores but less than the number of user-level threads.

40. Recap
Provide 2 programming example in which multithreading provides better performance than a single-threaded solution.
A Web server that services each request in a separate thread.
A parallelized application such as matrix multiplication where different parts of the matrix may be worked on in parallel.
An interactive GUI program such as a debugger where a thread is used to monitor user input, another thread represents the running application, and a third thread monitors performance.
What are at least 2 differences between a kernel thread and a user thread?
User-level threads are unknown by the kernel, whereas the kernel is aware of kernel threads.
On systems using either M:1 or M:N mapping, user threads are scheduled by the thread library and the kernel schedules kernel threads.
Kernel threads need not be associated with a process whereas every user thread belongs to a process. Kernel threads are generally more expensive to maintain than user threads as they must be represented with a kernel data structure.

41. Recap
What is the difference between creating and managing processes and threads (e.g., what do they share)?
Process (using fork()):
Makes a COPY of the process (global & local variables)
Shares open files (e.g., pipes)
Execution starts directly after fork()
Threads (using pthread_create() / CreateThread()):
Shares global variables, memory space (e.g., things on the heap), open files, etc.
Execution starts in functions
<Timing example: timing-*.c>
Which of the following components of program state are shared across threads in a multithreaded process? (Exercise 4.10)
Register values, Heap memory, Global variables, Stack memory

42. Recap
Consider a multiprocessor system and a multithreaded program written using the many-to-many threading model. Let the number of user-level threads in the program be more than the number of processors in the system. Discuss the performance implications of the following scenarios: (Exercise 4.10)
The number of kernel threads allocated to the program is less than the number of processors.
Not all of the processors will be utilized
The number of kernel threads allocated to the program is equal to the number of processors.
Whenever a kernel thread is blocked, a processor will go unutilized
The number of kernel threads allocated to the program is greater than the number of processors but less than the number of user-level threads.
Allows for the greatest utilization of processors and the kernel threads will be scheduled on the processors

43. End of Chapter 4