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) L1$ L2$ MMU (+TLB) Reg. 1 cycle 5 cycles 25 cycles

5. Single and Multithreaded Processes

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

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: – 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 CPU registers memory Open files Accounting state

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

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

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

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

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

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

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

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

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

26. Examples

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

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

29. OpenMP Parallelism

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

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

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

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

34. Java Thread States

35. 參考、引用文獻 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