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 cache miss (~1MB) CPU (core) L1$ L2$ MMU (+TLB) Reg. 1 cycle 5 cycles 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 CPU registers memory Open files Accounting state

One-to-one Model (Example: Linux) User space Kernel space Task 1 Task 2 PCB 1 PCB 2 Memory control block 1 Task 3 PCB 3 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

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

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.Semantics of fork() and exec() system calls 2.Thread cancellation 3.Signal handling 4.Thread pools 5.Thread specific data 6.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 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)

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, 7 th edition Linux kernel development, 2 nd edition Understanding the Linux Kernel, 3 rd edition Solaris™ Internals: Solaris 10 and OpenSolaris Kernel Architecture, 2 nd edition Wikipedia