CSE 120 Principles of Operating Systems Spring 2009 Lecture 4 Threads Geoffrey M Voelker Announcements Homework 1 due now Project 0 due tonight Project 1 out April 9 2009 CSE 120 Lecture 4 Threads 2 Processes Recall that a process includes many things Creating a new process is costly because of all of the data structures that must be allocated and initialized An address space defining all the code and data pages OS resources e g open files and accounting information Execution state PC SP regs etc Recall struct proc in Solaris which does not even include page tables perhaps TLB flushing etc Communicating between processes is costly because most communication goes through the OS April 9 2009 Overhead of system calls and copying data CSE 120 Lecture 4 Threads 3 Parallel Programs Also recall our Web server example that forks off copies of itself to handle multiple simultaneous requests Or any parallel program that executes on a multiprocessor To execute these programs we need to Create several processes that execute in parallel Cause each to map to the same address space to share data They are all part of the same computation Have the OS schedule these processes in parallel logically or physically This situation is very inefficient April 9 2009 Space PCB page tables etc Time create data structures fork and copy addr space etc CSE 120 Lecture 4 Threads 4 Rethinking Processes What is similar in these cooperating processes What don t they share Each has its own execution state PC SP and registers Key idea Why don t we separate the concept of a process from its execution state They all share the same code and data address space They all share the same privileges They all share the same resources files sockets etc Process address space privileges resources etc Execution state PC SP registers Exec state also called thread of control or thread April 9 2009 CSE 120 Lecture 4 Threads 5 Threads Modern OSes Mach Chorus NT modern Unix separate the concepts of processes and threads A thread is bound to a single process The thread defines a sequential execution stream within a process PC SP registers The process defines the address space and general process attributes everything but threads of execution Processes however can have multiple threads Threads become the unit of scheduling April 9 2009 Processes are now the containers in which threads execute Processes become static threads are the dynamic entities CSE 120 Lecture 4 Threads 6 Threads in a Process Thread 1 Stack T1 Thread 2 Stack T2 Stack T3 Thread 3 Heap Static Data PC T3 PC T2 Code PC T1 April 9 2009 CSE 120 Lecture 4 Threads 7 Thread Design Space One Thread Process One Address Space MSDOS One Thread Process Many Address Spaces Early Unix Many Threads Process One Address Space Pilot Java Many Threads Process Many Address Spaces Mach Unix NT Chorus Address Space Thread April 9 2009 CSE 120 Lecture 4 Threads 8 Process Thread Separation Separating threads and processes makes it easier to support multithreaded applications Concurrency multithreading can be very useful Concurrency does not require creating new processes Improving program structure Handling concurrent events e g Web requests Writing parallel programs So multithreading is even useful on a uniprocessor April 9 2009 CSE 120 Lecture 4 Threads 9 Threads Concurrent Servers Using fork to create new processes to handle requests in parallel is overkill for such a simple task Recall our forking Web server while 1 int sock accept if child pid fork 0 Handle client request Close socket and exit else Close socket April 9 2009 CSE 120 Lecture 4 Threads 10 Threads Concurrent Servers Instead we can create a new thread for each request web server while 1 int sock accept thread fork handle request sock handle request int sock Process request close sock April 9 2009 CSE 120 Lecture 4 Threads 11 Kernel Level Threads We have taken the execution aspect of a process and separated it out into threads As such the OS now manages threads and processes To make concurrency cheaper All thread operations are implemented in the kernel The OS schedules all of the threads in the system OS managed threads are called kernel level threads or lightweight processes April 9 2009 NT threads Solaris lightweight processes LWP POSIX Threads pthreads PTHREAD SCOPE SYSTEM CSE 120 Lecture 4 Threads 12 Kernel Thread Limitations Kernel level threads make concurrency much cheaper than processes Much less state to allocate and initialize However for fine grained concurrency kernel level threads still suffer from too much overhead Thread operations still require system calls Ideally want thread operations to be as fast as a procedure call Kernel level threads have to be general to support the needs of all programmers languages runtimes etc For such fine grained concurrency need even cheaper threads April 9 2009 CSE 120 Lecture 4 Threads 13 User Level Threads To make threads cheap and fast they need to be implemented at user level Kernel level threads are managed by the OS User level threads are managed entirely by the run time system user level library User level threads are small and fast A thread is simply represented by a PC registers stack and small thread control block TCB Creating a new thread switching between threads and synchronizing threads are done via procedure call No kernel involvement April 9 2009 User level thread operations 100x faster than kernel threads pthreads PTHREAD SCOPE PROCESS CSE 120 Lecture 4 Threads 14 Small and Fast Nachos thread control block class Thread int stack int stackTop int machineState MachineStateSize ThreadStatus status char name Methods April 9 2009 CSE 120 Lecture 4 Threads 15 U L Thread Limitations But user level threads are not a perfect solution User level threads are invisible to the OS They are not well integrated with the OS As a result the OS can make poor decisions As with everything else they are a tradeoff Scheduling a process with idle threads Blocking a process whose thread initiated an I O even though the process has other threads that can execute Unscheduling a process with a thread holding a lock Solving this requires communication between the kernel and the user level thread manager April 9 2009 CSE 120 Lecture 4 Threads 16 Kernel vs User Threads Kernel level threads User level threads Integrated with OS informed scheduling Slow to create manipulate synchronize Fast to create manipulate synchronize Not integrated with OS uninformed scheduling Understanding the
View Full Document
Unlocking...