CSE 120 Principles of Operating Systems Winter 2007 Lecture 4 Threads Keith Marzullo and Geoffrey M Voelker Announcements z z z Homework 1 due now Project 0 due tonight Project groups Please send project group info to Jeremy or Mike Project 1 out no time like the present January 18 2007 CSE 120 Lecture 4 Threads 2 1 Processes z Recall that a process includes many things z Creating a new process is costly because of all of the data structures that must be allocated and initialized z An address space p defining g all the code and data p pages g 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 flushing etc Communicating between processes is costly because most communication goes through the OS Overhead of system calls and copying data January 18 2007 CSE 120 Lecture 4 Threads 3 Parallel Programs z Also recall our Web server example that forks off copies of itself to handle multiple simultaneous requests z 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 z Have the OS schedule these p processes in p parallel logically g y or physically This situation is very inefficient Space PCB page tables etc Time create data structures fork and copy addr space etc January 18 2007 CSE 120 Lecture 4 Threads 4 2 Rethinking Processes z What is similar in these cooperating processes z What don t they share z 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 z 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 January 18 2007 CSE 120 Lecture 4 Threads 5 Threads z Modern OSes Mach Chorus NT modern Unix separate the concepts of processes and threads z A thread is bound to a single process z 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 Processes are now the containers in which threads execute Processes become static threads are the dynamic entities January 18 2007 CSE 120 Lecture 4 Threads 6 3 Threads in a Process Stack T1 Thread 2 Thread 1 Stack T2 Stack T3 Thread 3 Heap Static Data PC T3 PC T2 Code PC T1 January 18 2007 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 January 18 2007 CSE 120 Lecture 4 Threads 8 4 Process Thread Separation z Separating threads and processes makes it easier to support multithreaded applications z Concurrency multithreading can be very useful z Creating 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 January 18 2007 CSE 120 Lecture 4 Threads 9 Threads Concurrent Servers z z 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 January 18 2007 CSE 120 Lecture 4 Threads 10 5 Threads Concurrent Servers z 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 January 18 2007 CSE 120 Lecture 4 Threads 11 Kernel Level Threads Kernel z We have taken the execution aspect of a process and separated it out into threads z As such the OS now manages threads and processes z 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 NT threads Solaris lightweight processes LWP January 18 2007 CSE 120 Lecture 4 Threads 12 6 Kernel Thread Limitations z Kernel level threads make concurrency much cheaper than processes z 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 z Kernel level threads have to be g general to support pp the needs of all programmers languages runtimes etc For such fine grained concurrency need even cheaper threads January 18 2007 CSE 120 Lecture 4 Threads 13 User Level Threads User z To make threads cheap and fast they need to be implemented at user level z 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 User level thread operations 100x faster than kernel threads January 18 2007 CSE 120 Lecture 4 Threads 14 7 Small and Fast z Nachos thread control block class Thread int stack int stackTop int machineState MachineStateSize ThreadStatus status char name Methods January 18 2007 CSE 120 Lecture 4 Threads 15 U L Thread Limitations z But user level threads are not a perfect solution z User level threads are invisible to the OS z They are not well integrated with the OS As a result the OS can make poor decisions z As with everything else 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 January 18 2007 CSE 120 Lecture 4 Threads 16 8 Kernel vs User Threads
View Full Document
Unlocking...