1. CMSC 421 Spring 2004 Section 0202 Part II: Process Management Chapter 5 Threads

2. Silberschatz, Galvin and Gagne  2002 5.2 Operating System Concepts Contents Overview Multithreading Models Threading Issues Pthreads Solaris 2 Threads Windows 2000 Threads Linux Threads Java Threads

3. Silberschatz, Galvin and Gagne  2002 5.3 Operating System Concepts Lightweight Process and Heavyweight Process Lightweight Process (LWP) or thread  Basic unit of CPU control  Typically has private –Id, PC, register set, stacks, local storage  Shares OS resources with containing process –Address space (Code section, data section), open files, etc Heavyweight Process (HWP)  Single thread

4. Silberschatz, Galvin and Gagne  2002 5.4 Operating System Concepts Single and Multithreaded Processes

5. Silberschatz, Galvin and Gagne  2002 5.5 Operating System Concepts Benefits Responsiveness  Interactive program responds to user even when some threads are blocked doing other activities Resource Sharing  Shared address space, etc Economy  Lower overhead in creating and context switching threads than processes  context switch is 5 times faster  Thread creation is 30 times faster Utilization of multi-processor architectures  Multiple threads can run on multiple processors

6. Silberschatz, Galvin and Gagne  2002 5.6 Operating System Concepts User Threads Thread management done by a user-level threads library  Kernel is unaware of user-level threads  User-level threads are faster to create and manage  However, if a thread is blocked on a system call, the process is blocked too, and none of its other threads continues to run Examples - POSIX Pthreads - Mach C-threads - Solaris 2 threads

7. Silberschatz, Galvin and Gagne  2002 5.7 Operating System Concepts Kernel Threads Thread management is supported by the Kernel  Slower than user threads  But kernel can schedule another thread when one thread performs a blocking system call Examples - Windows 95/98/NT/2000 - Solaris - Tru64 UNIX - BeOS - Linux

8. Silberschatz, Galvin and Gagne  2002 5.8 Operating System Concepts Multithreading Models Three models for implementing threads  Many-to-One  One-to-One  Many-to-Many

9. Silberschatz, Galvin and Gagne  2002 5.9 Operating System Concepts Many-to-One Model

10. Silberschatz, Galvin and Gagne  2002 5.10 Operating System Concepts Many-to-One Many user-level threads are mapped to a single kernel thread. Multiple threads CANNOT run in parallel in a multiprocessor system A blocked thread blocks its process Used on systems that do not support kernel threads. Example  Solaris 2 Green Threads Library

11. Silberschatz, Galvin and Gagne  2002 5.11 Operating System Concepts One-to-one Model

12. Silberschatz, Galvin and Gagne  2002 5.12 Operating System Concepts One-to-One Each user-level thread maps to kernel thread. Can burden OS and slowdown application when many threads are created (due to kernel overhead) Examples - Windows 95/98/NT/2000 - OS/2

13. Silberschatz, Galvin and Gagne  2002 5.13 Operating System Concepts Many-to-Many Model

14. Silberschatz, Galvin and Gagne  2002 5.14 Operating System Concepts 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, and map user threads to them Addresses the shortcomings of the many-to-one and one- to-one models Examples  Solaris 2  Windows NT/2000 with the ThreadFiber package

15. Silberschatz, Galvin and Gagne  2002 5.15 Operating System Concepts Threading Issues Semantics of fork() and exec() system calls Thread cancellation Signal handling Thread pools Thread specific data

16. Silberschatz, Galvin and Gagne  2002 5.16 Operating System Concepts fork() and exec() semantics fork()  Does it duplicate ALL threads of the forking process?  Two flavors: one that duplicates and one that does not Exec()  Replaces the whole process  Including all threads (LWPs)

17. Silberschatz, Galvin and Gagne  2002 5.17 Operating System Concepts Thread Cancellation Canceling a target thread  Asynchronous cancellation (immediate termination)  Deferred cancellation  Target thread periodically checks if it should terminate Issues:  reclaiming resources of cancelled target thread  Shared resources with other threads Cancellation points

18. Silberschatz, Galvin and Gagne  2002 5.18 Operating System Concepts Signal Handling Signal => Notify the process of the occurrence of a certain event Types of signals  Synchronous  Delivered to the same process that generated the signal  Illegal memory access, division by zero, overflow  Asynchronous  Generally, delivered to a different process than the one generating the signal , timer expiry Signals handled using  Default signal handler (run by the kernel)  User-defined signal handler

19. Silberschatz, Galvin and Gagne  2002 5.19 Operating System Concepts Signal Handling (Cont.) Options for delivering signals (depending on signal)  Only to the thread that generated the signal  To all threads of a process  To all threads not blocking the signal  To a specific/dedicated thread Threads many choose to block certain signals

20. Silberschatz, Galvin and Gagne  2002 5.20 Operating System Concepts Thread Pools and Thread-specific Data Thread pools  Creating a large number of threads in a system can exhaust system resources  Allocate a pool of thread’s  Allocate available threads from the thread pool to a new “thread”  Reduces thread creation time when a request arrives Thread-specific data  Need for supporting private storage for threads that need to manage their own private data

21. Silberschatz, Galvin and Gagne  2002 5.21 Operating System Concepts Pthreads a POSIX standard (IEEE 1003.1c) API for thread creation, synchronization, and management API specifies behavior of the thread library, implementation is up to development of the library. Common in UNIX operating systems

22. Silberschatz, Galvin and Gagne  2002 5.22 Operating System Concepts Solaris 2 Threads Implements the Pthread API + support for user and kernel threads Uses LWP to multiplex user threads  Implements many-to-many model LWP reside in kernel space Allocates a kernel thread to each LWP User threads can be bound to a LWP or can be unbound Each user thread contains  Thread ID, register set (PC and stack pointer), stack,, and priority Each LWP contains  Register set for running user thread, stack, memory, and accounting info

23. Silberschatz, Galvin and Gagne  2002 5.23 Operating System Concepts Solaris 2 Threads

24. Silberschatz, Galvin and Gagne  2002 5.24 Operating System Concepts Solaris Process

25. Silberschatz, Galvin and Gagne  2002 5.25 Operating System Concepts Pthreads Example #include int sum = 0; /* shared data of the threads */ void *runner(void *p); int main(int argc, char *argv[]) { pthread_attr_t attr; pthread_t tid; pthread_attr_init(&attr); pthread_create(&tid, &attr, runner, argv[1]); /* create a thread and exec runner*/ pthread_join(tid, NULL); /* wait for thread to finish exec */ printf(“%d\n”, sum); exit(0); } void *runner(void *param) { int n = 0, i; n = atoi(param); sum = 0; for(i=0; i;<n; i++) sum += i; pthread_exit(0); }

26. Silberschatz, Galvin and Gagne  2002 5.26 Operating System Concepts Windows 2000 Threads Implements the one-to-one mapping. Each thread contains - a thread id - register set - separate user and kernel stacks - private data storage area

27. Silberschatz, Galvin and Gagne  2002 5.27 Operating System Concepts Linux Threads Thread creation is done through clone() system call Linux’s trick  Store process information in separate structures and use pointers to point to them instead of storing it directly in the data structure for the process Clone() allows a child task to share the address space of the parent task (process) Linux refers to them as tasks rather than threads.

28. Silberschatz, Galvin and Gagne  2002 5.28 Operating System Concepts Java Threads Java threads may be created by:  Extending Thread class  Implementing the Runnable interface Java threads are managed by the JVM. Java thread implementation depends on how the JVM is implemented on the host OS  Can be one-to-one for JVMs on Windows 2000 etc systems  Can be many-tone on Solaris 2 green thread JVM systems

29. Silberschatz, Galvin and Gagne  2002 5.29 Operating System Concepts Java Thread Example class Summation extends Thread { private int bound = 0; public Summation(int n) { bound = n; } public void run() { int sum = 0; for(int I=0; I<bound; I++) sum += I; System.out.println(“Sum = “ + sum); } public class Test { public static void main(String[] args) { Summation thr = new Summation(Integer.parseInt(args[0]); thr.start(); }

30. Silberschatz, Galvin and Gagne  2002 5.30 Operating System Concepts Java Thread States