CMSC 421 Spring 2004 Section 0202

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

2. Contents • Overview • Multithreading Models • Threading Issues • Pthreads • Solaris 2 Threads • Windows 2000 Threads • Linux Threads • Java Threads Operating System Concepts

3. 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 Operating System Concepts

4. Single and Multithreaded Processes Operating System Concepts

5. 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 Operating System Concepts

6. 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 Operating System Concepts

7. 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 Operating System Concepts

8. Multithreading Models • Three models for implementing threads • Many-to-One • One-to-One • Many-to-Many Operating System Concepts

9. Many-to-One Model Operating System Concepts

10. 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 Operating System Concepts

11. One-to-one Model Operating System Concepts

12. 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 Operating System Concepts

13. Many-to-Many Model Operating System Concepts

14. 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 Operating System Concepts

15. Threading Issues • Semantics of fork() and exec() system calls • Thread cancellation • Signal handling • Thread pools • Thread specific data Operating System Concepts

16. 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) Operating System Concepts

17. 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 Operating System Concepts

18. 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 • <control><C>, timer expiry • Signals handled using • Default signal handler (run by the kernel) • User-defined signal handler Operating System Concepts

19. 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 Operating System Concepts

20. 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 Operating System Concepts

21. 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 Operating System Concepts

22. 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 Operating System Concepts

23. Solaris 2 Threads Operating System Concepts

24. Solaris Process Operating System Concepts

25. Pthreads Example #include <pthread.h> #include <stdio.h> 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); } Operating System Concepts

26. 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 Operating System Concepts

27. 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. Operating System Concepts

28. 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 Operating System Concepts

29. 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(); } } Operating System Concepts

30. Java Thread States Operating System Concepts