1. Course: Operating Systems Instructor: Umar Kalim NUST Institute of Information Technology, Pakistan http://www.niit.edu.pk Operating Systems

2. Threads Overview Multithreading Models Threading Issues

3. Overview A thread is a basic unit of CPU utilization A traditional (or heavyweight) process has a single thread of control Single-threaded applications − Simple implementations e.g. assignments Multi-threaded applications − Web browser − Web server

4. Single and Multithreaded Processes ThreadID Program counter Registers Stack

5. Relationship between threads and processes The operating system creates a process for the purpose of running a program. − Every process has at least one thread. On some operating systems, a process can have more than one thread. − Some programs like word processors are designed to have only one instance of themselves running at the same time. Sometimes, such programs just open up more windows to accommodate multiple simultaneous use. After all, you can go back and forth between five documents, but you can only edit one of them at a given instance. − Command line interpreters and multiple users ~ processes Access rights Protection of other users from failures − Graphical User Interface ~ threads Multiple aspects at one instance, user input and painting

6. Processes and Threads The concept of a process and thread are interrelated by a sense of ownership and of containment Process − A process is the "heaviest" unit of kernel scheduling − Processes own resources allocated by the operating system Resources include memory, file handles, sockets, device handles, and user interfaces. − Processes do not share address spaces or file resources except through explicit methods − Processes are typically pre-emptively multitasked. However, Windows 3.1 and older versions of Mac OS used co- operative or non-preemptive multitasking.

7. Processes and Threads Thread − A thread is the "lightest" unit of kernel scheduling. − At least one thread exists within each process. − If multiple threads can exist within a process, then they share the same memory and file resources. − Threads are pre-emptively multitasked if the operating system's process scheduler is pre-emptive. − Threads do not own resources except for a stack and a copy of the registers including the program counter.

8. Benefits Responsiveness − blocking and non-blocking requests Resource Sharing − same address space Economy − Allocating resources to processes as compared to sharing resources via threads Utilization of MP Architectures − Multi-threaded applications can utilize multiprocessor platforms by enhancing concurrency

9. Multi-threading and reality In an ideal world, five processors would do five times the work of one processor But we live in a world of contention for shared resources, of disk and memory bottlenecks, single- threaded applications, multithreaded applications that require synchronous processing, and poorly coordinated processors

10. Course: Operating Systems Instructor: Umar Kalim NUST Institute of Information Technology, Pakistan http://www.niit.edu.pk Types of threads Kernel threads User level threads

11. Kernel threads A kernel thread is a kernel entity, like processes and interrupt handlers It is the entity handled by the system scheduler. Kernel threads consist of a set of registers, a stack, and a few corresponding kernel data structures. − The user structure contains process-related information − The uthread structure contains thread-related information. Unlike processes, all threads within a process share the same address space. Similar to processes, when a kernel thread makes a blocking call, only that thread blocks. All modern machines support kernel threads, most often via the POSIX threads interface ``pthreads''. − Some dedicated parallel machines support kernel threads poorly or not at all. For example, the Blue Gene/L microkernel does not support pthreads.

12. Kernel threads The advantage of kernel threads over processes is faster creation and context switching compared with processes. Parallel programming Kernel threads cannot be accessed from the user mode environment, except through the threads library.

13. Kernel Threads Supported by the Kernel Examples − Windows XP/2000 − Solaris − Linux − Tru64 UNIX − Mac OS X

14. User level threads Like a kernel thread, a user-level thread includes a set of registers and a stack, and shares the entire address space with the other threads in the enclosing process Unlike a kernel thread, however, a user-level thread is handled entirely in user code OS is unaware of a user-level thread's existence The primary advantages of user-level threads are efficiency and flexibility − Because the operating system is not involved, user-level threads can be made to use very little memory − User-level threads are also more flexible because the thread scheduler is in user code, for example, the application's priority structure can be directly used by the thread scheduler

15. User level threads The primary disadvantage of user-level threads compared to kernel threads is the lack of operating system support. − For example, when a user-level thread makes a blocking call, the kernel does not start running another user-level thread. Instead, the kernel suspends the entire calling kernel thread or process, even though another user-level thread might be ready to run.

16. User Threads User threads are mapped to kernel threads by the threads library, in an implementation dependent manner. − The threads library uses a proprietary interface to handle kernel threads. Three primary thread libraries: − POSIX Pthreads − Win32 threads − Java threads

17. Course: Operating Systems Instructor: Umar Kalim NUST Institute of Information Technology, Pakistan http://www.niit.edu.pk Questions?

18. Multithreading Models Many-to-One One-to-One Many-to-Many

19. Many-to-One Many user-level threads mapped to single kernel thread Entire process will block if a thread makes a blocking call Examples: − Solaris Green Threads − GNU Portable Threads

20. One-to-One Each user-level thread maps to kernel thread Examples − Windows NT/XP/2000 − Linux − Solaris 9 and later

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

22. Many-to-Many Model

23. Two-level Model Similar to M:M, except that it allows a user thread to be bound to kernel thread Examples − IRIX − HP-UX − Tru64 UNIX − Solaris 8 and earlier

24. Two-level Model

25. Threading Issues Semantics of fork() and exec() system calls Thread cancellation Signal handling Thread pools Thread specific data Scheduler activations

26. Semantics of fork() and exec() Does fork() duplicate only the calling thread or all threads?

27. Thread Cancellation Terminating a thread before it has finished − E.g. Multiple threads searching in a DB, if one thread finds the result, cancel the others Two general approaches: − Asynchronous cancellation terminates the target thread immediately Cancellation during data update ~ consistency issues − Deferred cancellation allows the target thread to periodically check if it should be cancelled Cancellation points

28. Signal Handling Signals are used in UNIX systems to notify a process that a particular event has occurred − Synchronous ~ same process, divide by zero − Asynchronous ~ external event, terminate process A signal handler is used to process signals 1. Signal is generated by particular event 2. Signal is delivered to a process 3. Signal is handled Handlers − Default − User defined Options − Deliver the signal to the thread to which the signal applies − Deliver the signal to every thread in the process − Deliver the signal to certain threads in the process − Assign a specific thread to receive all signals for the process

29. Thread Pools Create a number of threads in a pool where they await work − Web server Advantages: − Usually slightly faster to service a request with an existing thread than create a new thread − Allows the number of threads in the application(s) to be bound to the size of the pool

30. Course: Operating Systems Instructor: Umar Kalim NUST Institute of Information Technology, Pakistan http://www.niit.edu.pk Questions? Recommended Reading: − Book ~ 143 - 146 − OSRC http://www.nondot.org/sabre/os/articles − Reading list @ http://www.niit.edu.pk/~umarkalim/courses/fall2006/os.html