ECE3055 Computer Architecture and Operating Systems Lecture 12 Threads

1. ECE3055 Computer Architecture and Operating SystemsLecture 12 Threads Prof. Hsien-Hsin Sean Lee School of Electrical and Computer Engineering Georgia Institute of Technology

2. Single and Multithreaded Processes

3. Examples of Threads • A web browser • One thread displays images • One thread retrieves data from network • A word processor • One thread displays graphics • One thread reads keystrokes • One thread performs spell checking in the background • A web server • One thread accepts requests • When a request comes in, separate thread is created to service • Many threads to support thousands of client requests • RPC or RMI (Java) • One thread receives message • Message service uses another thread

4. Thread A thread has no data segment or heap A thread cannot live on its own, it must live within a process There can be more than one thread in a process, the first thread calls main and has the process’s stack Inexpensive creation Inexpensive context switching If a thread dies, its stack is reclaimed by the process Processes A process has code/data/heap and other segments There must be at least one thread in a process Threads within a process share code/data/heap, share I/O, but each has its own stack and registers Expense creation Expensive context switching It a process dies, its resources are reclaimed and all threads die Threads vs. Processes

5. Thread Implementation • Process defines address space • Threads share address space • Process Control Block (PCB) contains process-specific info • PID, owner, heap pointer, active threads and pointers to threadd info • Thread Control Block (TCB) contains thread-specific info • Stack pointer, PC, thread state, register … TCB for thread1 Process’s address space $pc $sp State Registers … … Reserved DLL’s Stack – thread 1 TCB for thread2 Stack – thread 2 $pc $sp State Registers … … Heap Initialized data CODE

6. Benefits • Responsiveness • When one thread is blocked, your browser still responds • E.g. download images while allowing your interaction • Resource Sharing • Share the same address space • Reduce overhead (e.g. memory) • Economy • Creating a new process costs memory and resources • E.g. in Solaris, 30 times slower in creating process than thread • Utilization of MP Architectures • Threads can be executed in parallel on multiple processors • Increase concurrency and throughput

7. User-level Threads • Thread management done by user-level threads library • Similar to calling a procedure • Thread management is done by the thread library in user space • User can control the thread scheduling (No disturbing the underlying OS scheduler) • No OS kernel support • more portable • Low overhead when thread switching • Three primary thread libraries: • POSIX Pthreads • Java threads • Win32 threads

8. Kernel Threads • A.k.a. lightweight process in the literature • Supported by the Kernel • Thread scheduling is fairer • Examples • Windows XP/2000 • Solaris • Linux • Tru64 UNIX • Mac OS X

9. Multithreading Models • Many-to-One • One-to-One • Many-to-Many

10. Many-to-One • Many user-level threads mapped to one single kernel thread • The entire process will block if a thread makes a blocking system call • Cannot run threads in parallel on multiprocessors • Examples • Solaris Green Threads • GNU Portable Threads

11. Many-to-One Model

12. One-to-One • Each user-level thread maps to kernel thread • Do not block other threads when one is making a blocking system call • Enable parallel execution in an MP system • Downside: • performance/memory overheads of creating kernel threads • Restriction of the number of threads that can be supported • Examples • Windows NT/XP/2000 • Linux • Solaris 9 and later

13. One-to-one Model

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 • Threads are multiplexed to a smaller (or equal) number of kernel threads which is specific to a particular application or a particular machine • Solaris prior to version 9 • Windows NT/2000 with the ThreadFiber package

15. Many-to-Many Model

16. Two-level (or Combined) Model • Similar to Many-to-Many, except that it also allows a user thread to be bound to kernel thread • Examples • IRIX • HP-UX • Tru64 UNIX • Solaris 8 and earlier (9 uses one-to-one model)

17. Two-level (or Combined) Model

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

19. Semantics of fork() and exec() • Does fork() duplicate only the calling thread or all threads? • Some UNIX systems have chosen to have 2 versions of fork() • Exec() : The program specified in the parameter to exec() will replace the entire process including all threads if a thread invokes it

20. Thread Cancellation • Terminating a thread before it has finished • Two general approaches: • Asynchronous cancellation terminates the target thread immediately • Deferred cancellation allows the target thread to periodically check if it should be cancelled

21. Signal Handling • Signals are used in UNIX systems to notify a process that a particular event has occurred • A signal handler is used to process signals • Signal is generated by particular event • Signal is delivered to a process • Signal is handled • 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 threa to receive all signals for the process

22. Thread Pools • 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

23. Thread Specific Data • Allows each thread to have its own copy of data • Useful when you do not have control over the thread creation process (i.e., when using a thread pool)

24. Scheduler Activations • Both M:M and Two-level models require communication to maintain the appropriate number of kernel threads allocated to the application • Scheduler activations provide upcalls - a communication mechanism from the kernel to the thread library • This communication allows an application to maintain the correct number kernel threads

25. Pthreads • A POSIX standard (IEEE 1003.1c) API for thread creation and synchronization • API specifies behavior of the thread library, implementation is up to development of the library • Common in UNIX operating systems (Solaris, Linux, Mac OS X)

26. Pthreads int sum; /* this data is shared by the thread(s) */ void *runner(void *param); /* the thread */ main(int argc, char *argv[]) { pthread_t tid; /* the thread identifier */ pthread_attr_t attr; /* set of attributes for the thread */ /* get the default attributes */ pthread_attr_init(&attr); /* create the thread */ pthread_create(&tid,&attr,runner,argv[1]); /* now wait for the thread to exit */ pthread_join(tid,NULL); printf("sum = %d\n",sum); } void *runner(void *param) { int upper = atoi(param); int i; sum = 0; if (upper > 0) { for (i = 1; i <= upper; i++) sum += i; } pthread_exit(0); }

27. Windows XP Threads • Implements the one-to-one mapping • 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)

28. Linux Threads • Linux refers to them as tasks rather than threads • Thread creation is done through clone() system call • clone() allows a child task to share the address space of the parent task (process)

29. Java Threads • Java threads are managed by the JVM • Java threads may be created by: • Extending Thread class • Implementing the Runnable interface

30. Extending the Thread Class class Worker1 extends Thread { publicvoid run() { System.out.println("I Am a Worker Thread"); } } publicclass First { publicstaticvoid main(String args[]) { Worker1 runner = new Worker1(); runner.start(); System.out.println("I Am The Main Thread"); } }

31. The Runnable Interface publicinterface Runnable { publicabstractvoid run(); }

32. Implementing the Runnable Interface class Worker2 implements Runnable { publicvoid run() { System.out.println("I Am a Worker Thread "); } } publicclass Second { publicstaticvoid main(String args[]) { Runnable runner = new Worker2(); Thread thrd = new Thread(runner); thrd.start(); System.out.println("I Am The Main Thread"); } }

33. Java Thread States

34. Joining Threads class JoinableWorker implements Runnable { publicvoid run() { System.out.println("Worker working"); } } publicclass JoinExample { publicstaticvoid main(String[] args) { Thread task = new Thread(new JoinableWorker()); task.start(); try { task.join(); } catch (InterruptedException ie) { } System.out.println("Worker done"); } }

35. Thread Cancellation Thread thrd = new Thread (new InterruptibleThread()); Thrd.start(); . . . // now interrupt it Thrd.interrupt();

36. Thread Cancellation publicclass InterruptibleThread implements Runnable { publicvoid run() { while (true) { /** * do some work for awhile */ if (Thread.currentThread().isInterrupted()) { System.out.println("I'm interrupted!"); break; } } // clean up and terminate } }

37. Thread Specific Data class Service { privatestatic ThreadLocal errorCode = new ThreadLocal(); publicstaticvoid transaction() { try { /** * some operation where an error may occur */ catch (Exception e) { errorCode.set(e); } } /** * get the error code for this transaction */ publicstatic Object getErrorCode() { return errorCode.get(); } }

38. Thread Specific Data class Worker implements Runnable { privatestatic Service provider; publicvoid run() { provider.transaction(); System.out.println(provider.getErrorCode()); } }

39. Producer-Consumer Problem publicclass Factory { public Factory() { // first create the message buffer Channel mailBox = new MessageQueue(); // now create the producer and consumer threads Thread producerThread = new Thread(new Producer(mailBox)); Thread consumerThread = new Thread(new Consumer(mailBox)); producerThread.start(); consumerThread.start(); } publicstaticvoid main(String args[]) { Factory server = new Factory(); } }

40. Producer Thread class Producer implements Runnable { private Channel mbox; public Producer(Channel mbox) { this.mbox = mbox; } publicvoid run() { Date message; while (true) { SleepUtilities.nap(); message = new Date(); System.out.println("Producer produced " + message); // produce an item & enter it into the buffer mbox.send(message); } } }

41. Consumer Thread class Consumer implements Runnable { private Channel mbox; public Consumer(Channel mbox) { this.mbox = mbox; } publicvoid run() { Date message; while (true) { SleepUtilities.nap(); // consume an item from the buffer System.out.println("Consumer wants to consume."); message = (Date)mbox.receive(); if (message != null) System.out.println("Consumer consumed " + message); } } }