Transcript threads

Chapter 4: Threads
羅習五
Chapter 4: Threads
•
•
•
•
Motivation and Overview
Multithreading Models
Threading Issues
Examples
– Pthreads
– Windows XP Threads
– Linux Threads
– Java Threads
Motivation the overhead of using processes
• Creating a new process needs many system
resources
– Process control block (TCB)
– xxx Control Block…
– Memory
–…
Motivation the overhead of using processes
• The overhead of context-switch
– + store/restore the register file (~1kB)
– + TLB miss (~1kB)
CPU
– + CPU cache miss (~1MB) (core)
Reg.
1 cycle
5 cycles
L1$
MMU (+TLB)
L2$
25 cycles
Single and Multithreaded Processes
Benefits
• Responsiveness
• Resource Sharing
– 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)
Multithreading Models
• Many-to-One
• One-to-One
• Many-to-Many
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
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
Many-to-One Model
One-to-One
• Each user-level thread maps to a kernel thread
• Pros:
– 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
One-to-one Model
The Linux Task Control Block
state
Accounting
CPU
registers
memory
Open files
One-to-one Model
(Example: Linux)
User
space
Task 1
Task 2
Task 3
Kernel
space
PCB 1
PCB 2
PCB 3
Memory control
block 1
Memory control
block 3
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);
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
Many-to-Many Model
LWP
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
Two-level Model
(~Solaris 8)
LWP
LWP
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.
Sun OS (Solaris 9 and 10)
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
Threading Issues
1.
2.
3.
4.
5.
6.
Semantics of fork() and exec() system calls
Thread cancellation
Signal handling
Thread pools
Thread specific data
Scheduler activations
Threading Issues
• fork() and exec()
– Does fork() duplicate only the calling thread or all
threads?
– exec() will replace the entire process including all
threads
• Cancellation
– Asynchronous cancellation
– Synchronous cancellation
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
Threading Issues
• Thread pools
– 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.
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
Examples
Pthreads
• A POSIX standard (IEEE 1003.1c) 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)
OpenMP
(Open Multi-Processing)
• OpenMP is an API that supports shared
memory multiprocessing programming in
C/C++ and Fortran.
• Version 3.1 is the current version of the
OpenMP specifications.
– the most interesting new features in 3.0 (and
later) is the concept of tasks.
– gcc 4.4 and later
OpenMP Parallelism
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
• C/C++ spec 3.1, July, '11
• The current stable version is gcc 4.6
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)
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)
Java Threads
• Java threads are managed by the JVM
• Java threads may be created by:
– Extending Thread class
– Implementing the Runnable interface
Java Thread States
參考、引用文獻
•
•
•
•
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