1. CISC2200 Threads Fall 09

2. Process  We learn the concept of process  A program in execution  A process owns some resources  A process executes a program => execution state, PC, …  We learn that bash creates processes to run user’s command  We practice with process creation in assignment  Create a child process  Parent process 2

3. OS: Protection 3  Protection: mechanism for controlling access of processes or users to resources (Files, memory segment, CPU and other)  Systems generally first distinguish among users to determine who can do what  User identities (user IDs): a unique name and number  User ID then associated with all files, processes of that user to determine access control  Group identifier (group ID) allows set of users to be defined, then also associated with each process, file

4. Hardware Support for protection 4  Dual-mode allows OS to protect itself and other system components  A mode bit provided by processor hardware  Kernel mode for running kernel code  User mode for running user code  Privileged instructions only executable in kernel mode  System call: changes mode to kernel, return from call resets it to user mode “ps” command: reports user time, system time

5. Single-threaded Processes 5

6. Multithreading 6  Separate two characteristics of process  Unit of dispatching => thread, lightweight process  Unit of resource ownership => process, task  Multi-threading: ability of OS to support multiple, concurrent paths of execution with a single process

7. Multithreading (cont’d) 7  Process: unit of resource allocation/protection  An address space for its image  Protected access to resources  Inter-process communication  Thread:  A thread execution state  Saved context,  Execution stack  Access to memory/resource of its process, shared with other threads in the process

8. Why Multithreading ?  Many applications require a set of related units of execution  Web Server example:  listening on port for client connection request  serving a client: read client request, serve the file  Can create multiple processes for them  Mainly performance consideration. Threads are  Faster to create a new thread, terminate a thread  Faster to switch between two threads within a process  More efficient communication between threads (without invoking kernel) 8

9. Multithreaded Server Architecture 9

10. Benefits of Threads 10  Responsiveness  Resource Sharing  Economy  Scalability  Increase parallelism, allow application to take advantage of multiprocessor architecture

11. Concurrent Execution 11 Parallel Execution (Multicore System)

12. User Threads vs Kernel Threads 12  Support for threads: provided at user level or kernel level  User thread: Thread management done by user-level threads library  Three primary thread libraries: POSIX Pthreads, Win32 threads, Java threads  Kernel thread: threads supported and managed by the Kernel  Examples: Windows XP/2000, Solaris, Linux, Tru64 UNIX, Mac OS X

13. Multithreading Models 13  Relationship between user threads and kernel threads  Many-to-One  One-to-One  Many-to-Many  Two-level model

14. Many-to-One, User-level threads 14  Advantage:  Thread switching requires no kernel mode (save time)  Application specific scheduling  Run on any OS  Disadvantage:  One thread blocking blocks all threads in process  A multithread app. cannot take advantage of multiprocessing  Examples: Solaris Green Threads. GNU Portable Threads Thread library  Multiple user-level threads mapped to a single kernel thread; user-level thread library implements all threading functionalities

15. One-to-One 15  Each user-level thread maps to kernel thread  Advantage? Disadvantage?  Examples  Windows NT/XP/2000, Linux, Solaris 9 and later

16. Many-to-Many Model 16  User-level thread library:  thread creation, scheduling, synchronization  Multiple user level threads mapped to some (smaller of equal) number of kernel threads  Programmer can adjust # of kernel threads  Ex:  Solaris prior to version 9, Windows NT/2000 with the ThreadFiber package Thread library

17. Two-level Model 17  Similar to Many-to-Many model, except that it allows a user thread to be bound to kernel thread  Examples  IRIX  HP-UX  Tru64 UNIX  Solaris 8 and earlier Thread library

18. Thread Libraries 18  Thread library provides programmer with API for creating and managing threads  Two primary ways of implementation  User-level library: library entirely in user space  Kernel-level library supported by the OS

19. Pthreads 19  A POSIX standard (IEEE 1003.1c) API for thread creation and synchronization  API specifies behavior of the thread library, implementation is up to developer of the library  May be provided either as user-level or kernel-level  Common in UNIX operating systems (Solaris, Linux, Mac OS X)

20.  #include #include int sum; /* this data is shared by the thread(s) */ void *runner(void *param); /* the thread */ int main(int argc, char *argv[]) { pthread_t tid; /* the thread identifier */ pthread_attr_t attr; /* set of attributes for the thread */ if (argc != 2) { fprintf(stderr,"usage: a.out \n"); return -1; } if (atoi(argv[1]) < 0) { fprintf(stderr,"Argument %d must be non-negative\n",atoi(argv[1])); return -1; } pthread_attr_init(&attr); /* get the default attributes */

21.  /* create the thread */ pthread_create(&tid,&attr,runner,argv[1]); pthread_join(tid,NULL); /* now wait for the thread to exit */ printf("sum = %d\n",sum); } /** * The thread will begin control in this function */ void *runner(void *param) { int i, upper = atoi(param); sum = 0; if (upper > 0) { for (i = 1; i <= upper; i++) sum += i; } pthread_exit(0); } 21 To compile: gcc –pthread main.c

22. Java Threads 22  Java threads are managed by the JVM  Typically implemented using the threads model provided by underlying OS  Java threads may be created by:  Extending Thread class  Implementing the Runnable interface

23. Threading Issues 23  Semantics of fork() and exec() system calls  Thread cancellation of target thread  Asynchronous or deferred  Signal handling  Thread pools

24. Semantics of fork() and exec() 24  Does fork() duplicate only the calling thread or all threads?  Some Unix provides two version of fork(), one duplicate all threads and another duplicates only the thread making fork() calls  exec() replace the entire process with the new program, including all threads

25. Thread Cancellation 25  Terminating a thread (referred to as target thread) before it finishes  Two general approaches:  Asynchronous cancellation terminates target thread immediately  Problematic if target thread is updating shared data, or has allocated some resource  Deferred cancellation allows target thread to periodically check (at cancellation points) if it should be cancelled

26. Signal Handling 26 Signals are used in UNIX systems to notify a process that a particular event has occurred 1. Signal is generated by particular event: segmentation fault, division by error, ctrl-c, kill …. 2. Signal is delivered to a process 3. Signal is handled by the process A signal handler is used to process signals Default signal handler, user-defined signal handler

27. Signal Handling & multi-threading 27 Deliver signal to all threads within the process, or just one particular thread ? Options: – Deliver 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 and process the signals

28. Thread Pools 28  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 the application(s) to be bound to the size of the pool

29. Windows XP Threads 29  Implements the one-to-one mapping, kernel-level  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)

30. Linux Threads 30  Linux does not distinguish between processes and threads  Linux refers to them as tasks rather than threads  A flow of control within a program  System call clone(): create a new task, with flags specify the level of sharing between parent and child task  CLONE_FS: file system info is shared  CLONE_VM: memory space is shared  CLOSE_SIGHAND: signal handlers are shared  CLONE_FILES: the set of open files is shared  How to create a task with similar sharing of threads as described in this class ?  How to create a task with similar sharing as process ?