1. ThreadsCS-3013 C-term 20081 Threads (continued) CS-3013, Operating Systems C-Term 2008 (Slides include materials from Operating System Concepts, 7 th ed., by Silbershatz, Galvin, & Gagne and from Modern Operating Systems, 2 nd ed., by Tanenbaum)

2. ThreadsCS-3013 C-term 20082 Review Threads introduced because Processes are heavyweight in Windows and Linux Difficult to develop concurrent applications when address space is unique per process Thread — a particular execution of a program within the context of a Windows- Unix-Linux process Multiple threads in same address space at same time

3. ThreadsCS-3013 C-term 20083 This problem … … is partly an artifact of Unix, Linux, and Windows and of Big, powerful processors (e.g., Pentium, Athlon) … tends to occur in most large systems … is infrequent in small-scale systems PDAs, cell phones Closed systems (i.e., controlled applications)

4. ThreadsCS-3013 C-term 20084 Characteristics A thread has its own Program counter, registers, PSW Stack A thread shares Address space, heap, static data, program code Files, privileges, all other resources with all other threads of the same process

5. ThreadsCS-3013 C-term 20085 Address Space for Multiple Threads 0x00000000 0xFFFFFFFF Virtual address space code (text) static data heap thread 1 stack PC (T2) SP (T2) thread 2 stack thread 3 stack SP (T1) SP (T3) PC (T1) PC (T3) SP PC

6. ThreadsCS-3013 C-term 20086 Who creates and manages threads? User-level implementation –done with function library (e.g., POSIX) –Runtime system – similar to process management except in user space –Windows NT – fibers: a user-level thread mechanism ??? Kernel implementation – new system calls and new entity to manage –Linux: lightweight process (LWP) –Windows NT & XP: threads

7. ThreadsCS-3013 C-term 20087 Mutual Exclusion within Threads extern void thread_yield(); extern int TestAndSet(int &i); /* sets the value of i to 1 and returns the previous value of i. */ void enter_critical_region(int &lock) { while (TestAndSet(lock) == 1) thread_yield(); /* give up processor */ }; void leave_critical_region(int &lock) { lock = 0; };

8. ThreadsCS-3013 C-term 20088 Reading Assignment Silbertshatz –Chapter 4 – “Threads” Robert Love, Linux Kernel Development –Chapter 3 – “Process Management”

9. ThreadsCS-3013 C-term 20089 Kernel Threads Supported by the Kernel OS maintains data structures for thread state and does all of the work of thread implementation. Examples Solaris Tru64 UNIX Mac OS X Windows 2000/XP/Vista Linux version 2.6

10. ThreadsCS-3013 C-term 200810 Kernel Threads (continued) OS schedules threads instead of processes Benefits –Overlap I/O and computing in a process –Creation is cheaper than processes –Context switch can be faster than processes Negatives –System calls (high overhead) for operations –Additional OS data space for each thread

11. ThreadsCS-3013 C-term 200811 Threads – supported by processor E.g., Pentium 4 with Hyperthreading™ www.intel.com/products/ht/hyperthreading_more.htm Multiple processor cores on a single chip True concurrent execution within a single process Requires kernel thread support Re-opens old issues Deadlock detection Critical section management of synchronization primitives (especially in OS kernel)

12. ThreadsCS-3013 C-term 200812 Unix Processes vs. Threads On a 700 Mhz Pentium running Linux –Processes: fork()/exit() : 250 microsec –Kernel threads: pthread_create() / pthread_join() : 90 microsec –User-level threads: pthread_create() / pthread_join() : 5 microsec

13. ThreadsCS-3013 C-term 200813 POSIX pthread Interface Data type:– pthread_t int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void*(*start_routine) (void), void *arg) ; –creates a new thread of control –new thread begins executing at start_routine pthread_exit(void *value_ptr) –terminates the calling thread pthread_join(pthread_t thread, void **value_ptr); –blocks the calling thread until the thread specified terminates pthread_t pthread_self() –Returns the calling thread's identifier

14. ThreadsCS-3013 C-term 200814 Threads and “small” operating systems Many “small” operating systems provide a common address space for all concurrent activities Each concurrent execution is like a Linux- Unix thread But its often called a process! pthread interface and tools frequently used for managing these processes …

15. ThreadsCS-3013 C-term 200815 Java Threads Thread class Thread worker = new Thread(); Configure it Run it public class application extends Thread { … } Methods to Run, wait, exit Cancel, join Synchronize …

16. ThreadsCS-3013 C-term 200816 Threading Issues Semantics of fork() and exec() system calls for processes Thread cancellation Signal handling Kernel thread implementations –Thread pools –Thread specific data –Scheduler activations

17. ThreadsCS-3013 C-term 200817 Semantics of fork() and exec() Does fork() duplicate only the calling thread or all threads? –Easy if user-level threads –Not so easy with kernel-level threads Linux has special clone() operation – only forking thread is created in child process Windows XP has something similar

18. ThreadsCS-3013 C-term 200818 Thread Cancellation Terminating a thread before it has finished Reason:– Some other thread may have completed the joint task E.g., searching a database Issue:– Other threads may be depending cancelled thread for resources, synchronization, etc. May not be able to cancel one until all can be cancelled

19. ThreadsCS-3013 C-term 200819 Thread Cancellation (continued) Two general approaches: –Asynchronous cancellation terminates the target thread immediately –Deferred cancellation allows the target thread to periodically check if it should cancel itself pthreads provides cancellation points

20. ThreadsCS-3013 C-term 200820 Signal Handling Signals are used in Unix-Linux to notify process that a particular event has occurred — e.g. –Divide-by-zero –Illegal memory access, stack overflow, etc. –CTL-C typed, or kill command issued at console –Timer expiration; external alarm –… A signal handler is used to process signals –Signal is generated by particular event –Signal is delivered to a process –Signal is handled by a signal handler All processes provided with default signal handler Applications may install own handlers for specific signals

21. ThreadsCS-3013 C-term 200821 Signal Handling Options Deliver signal to specific thread to which it applies E.g., illegal memory access, divide-by-zero, etc. Deliver signal to every thread in the process CTL-C typed Deliver signal to certain threads in the process I.e., threads that have agreed to receive such signals (or not blocked them) Assign a specific thread to receive all signals for the process …

22. ThreadsCS-3013 C-term 200822 Kernel Thread Implementations Linux Windows Others

23. ThreadsCS-3013 C-term 200823 Modern Linux Thread Implementation Implemented directly in kernel Primary unit of scheduling and computation implemented by Linux 2.6 kernel “A thread is just a special kind of process.” Robert Love, Linux Kernel Development, p.23 Every thread has its own task_struct in kernel …

24. ThreadsCS-3013 C-term 200824 Definition Task (from point of view of Linux kernel):– –Process –Thread –Kernel thread (see later)

25. ThreadsCS-3013 C-term 200825 Modern Linux Threads (continued) Process task_struct has pointer to own memory & resources Thread task_struct has pointer to process’s memory & resources Kernel thread task_struct has null pointer to memory & resources fork() and pt hread_create() are library functions that invoke clone() system call Arguments specify what kind of clone …

26. ThreadsCS-3013 C-term 200826 Modern Linux Threads (continued) Threads are scheduled independently of each other Threads can block independently of each other Even threads of same process Threads can make their own kernel calls Kernel maintains a small kernel stack per thread During kernel call, kernel is in process context

27. ThreadsCS-3013 C-term 200827 Process Context 0x00000000 0xFFFFFFFF Virtual address space code (text) static data heap (dynamically allocated ) Kernel Code and Data PC SP1 User Space stack (dynamically allocated ) Kernel Space 32-bit Linux & Win XP – 3G/1G user space/kernel space stack (dynamically allocated ) SP2

28. ThreadsCS-3013 C-term 200828 Modern Linux Threads (continued) Multiple threads can be executing in kernel at same time When in process context, kernel can sleep on behalf of its thread take pages faults on behalf of its thread move data between kernel and process address space on behalf of thread …

29. ThreadsCS-3013 C-term 200829 Linux Kernel Threads Kernel has its own threads No associated process context Supports concurrent activity within kernel Multiple devices operating at one time Multiple application activities at one time Multiple processors in kernel at one time A useful tool Special kernel thread packages, synchronization primitives, etc. Useful for complex OS environments

30. ThreadsCS-3013 C-term 200830 Windows XP Threads Much like to Linux 2.6 threads Primitive unit of scheduling defined by kernel Threads can block independently of each other Threads can make kernel calls … Process is a higher level (non-kernel) abstraction See Silbershatz, §22.3.2.2

31. ThreadsCS-3013 C-term 200831 Other Implementations of Kernel Threads Many-to-Many Many-to-One One-to-One

32. ThreadsCS-3013 C-term 200832 Thread Pools (Implementation technique) Create a number of threads in a pool where they await work Advantages: –Usually slightly faster to service a request with an existing thread than create a new thread –Allows the number of threads in application(s) to be bounded by size of pool

33. ThreadsCS-3013 C-term 200833 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 Thread/Fiber package

34. ThreadsCS-3013 C-term 200834 Many-to-Many Model

35. ThreadsCS-3013 C-term 200835 Two-level Model Similar to M:M, except it allows a specific thread to be bound to one kernel thread Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier

36. ThreadsCS-3013 C-term 200836 Two-level Model

37. ThreadsCS-3013 C-term 200837 Many-to-One Many user-level threads mapped to single kernel thread Examples: Solaris Green Threads GNU Portable Threads

38. ThreadsCS-3013 C-term 200838 Many-to-One Model

39. ThreadsCS-3013 C-term 200839 One-to-One Each user-level thread maps to kernel thread Examples Windows NT/XP/2000 Linux Solaris 9 and later

40. ThreadsCS-3013 C-term 200840 One-to-one Model

41. ThreadsCS-3013 C-term 200841 Threads – Summary Threads were invented to counteract the heavyweight nature of Processes in Unix, Windows, etc. Provide lightweight concurrency within a single address space Have evolved to become primitive abstraction defined by kernel Fundamental unit of scheduling in Linux, Windows, etc

42. ThreadsCS-3013 C-term 200842 Reading Assignment Silbertshatz –Chapter 4 – “Threads” Robert Love, Linux Kernel Development –Chapter 3 – “Process Management”

43. ThreadsCS-3013 C-term 200843 Questions?