View
228
Download
1
Embed Size (px)
Citation preview
ThreadsCS-3013 C-term 2008 1
Threads
CS-3013, Operating SystemsC-Term 2008
(Slides include materials from Operating System Concepts, 7th ed., by Silbershatz, Galvin, & Gagne and from Modern Operating Systems, 2nd ed., by Tanenbaum)
ThreadsCS-3013 C-term 2008 2
Problem
• Processes in Unix, Linux, and Windows are “heavyweight”
• OS-centric view – performance
• Application-centric view – flexibility and application design
ThreadsCS-3013 C-term 2008 3
OS-centric View of Problem
• Lots of data in PCB & other data structures• Even more when we study memory management
• More than that when we study file systems, etc.
• Processor caches a lot of information • Memory Management information
• Caches of active pages
• Costly context switches and traps• 100’s of microseconds
ThreadsCS-3013 C-term 2008 4
Application-centric View of Problem
• Separate processes have separate address spaces
• Shared memory is limited or nonexistent
• Applications with internal concurrency are difficult
• Isolation between independent processes vs. cooperating activities
• Fundamentally different goals
ThreadsCS-3013 C-term 2008 5
Example
• Web Server – How to support multiple concurrent requests
• One solution:– create several processes that execute in parallel– Use shared memory — shmget() — to map to the
same address space into multiple processes– have the OS schedule them in parallel
• Clumsy and inefficient– Space and time: PCB, page tables, cloning entire
process, etc.– programming: shmget()is really hard to program!
ThreadsCS-3013 C-term 2008 6
Example 2
• Transaction processing systems• E.g, airline reservations or bank ATM transactions
• 1000’s of transactions per second• Very small computation per transaction
• Separate processes per transaction are too costly
• Other techniques (e.g., message passing) are much more complex
ThreadsCS-3013 C-term 2008 7
Example 3
• Games have multiple active characters• Independent behaviors
• Common context or environment
• Need “real-time” response to user• For interactive gaming experience
• Programming all characters in separate processes is really, really hard!
• Programming them in a single process is much harder without concurrency support.
ThreadsCS-3013 C-term 2008 8
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)
ThreadsCS-3013 C-term 2008 9
Solution:– Threads
• A thread is a particular execution of a program or procedure within the context of a Unix or Windows process
• I.e., a specialization of the concept of process
• 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
ThreadsCS-3013 C-term 2008 10
Address Space Linux-Windows process
0x00000000
0xFFFFFFFF
Virtual
address space
program code(text)
static data
heap(dynamically allocated)
stack(dynamically allocated)
PC
SP
See also Silbershatz, figure 3.1
ThreadsCS-3013 C-term 2008 11
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
ThreadsCS-3013 C-term 2008 12
Single and Multithreaded Processes
ThreadsCS-3013 C-term 2008 13
Benefits
• Responsiveness
• Resource Sharing
• Economy
• Utilization of multi-processor architectures
ThreadsCS-3013 C-term 2008 14
Threads
• Unix, Windows, and older versions of Linux have their own thread interfaces
• Similar, not standardized
• Some issues• E.g., ERRNO in Unix — a static variable set by
system calls• Semantics of fork() and exec()
ThreadsCS-3013 C-term 2008 15
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
ThreadsCS-3013 C-term 2008 16
User Threads
• Thread management done by user-level threads library
• Three primary thread libraries: –– POSIX Pthreads– Win32 threads– Java threads
ThreadsCS-3013 C-term 2008 17
User Threads (continued)
• Can be implemented without kernel support• … or knowledge!
• Program links with a runtime system that does thread management
• Operation are very efficient (procedure calls)
• Space efficient and all in user space (TCB)
• Task switching is very fast
• Since kernel not aware of threads, there can be scheduling inefficiencies
• E.g., blocking I/O calls
• Non-concurrency of threads on multiple processors
ThreadsCS-3013 C-term 2008 18
User Threads (continued)
• Thread Dispatcher– Queues in process memory to keep track of threads’ state
• Scheduler – non-preemptive– Assume threads are well-behaved– Thread voluntarily gives up CPU by calling yield() – does thread
context switch to another thread
• Scheduler – preemptive– Assumes threads may not be well-behaved– Scheduler sets timer to create a signal that invokes scheduler– Scheduler can force thread context switch– Increased overhead
• Application or thread library must handle all concurrency itself!
ThreadsCS-3013 C-term 2008 19
Thread Interface
• E.g., POSIX pthreads API:– 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
ThreadsCS-3013 C-term 2008 20
Kernel Threads
• Supported by the Kernel• OS maintains data structures for thread state and
does all of the work of thread implementation.
• Examples• Windows XP/2000
• Solaris
• Linux version 2.6
• Tru64 UNIX
• Mac OS X
ThreadsCS-3013 C-term 2008 21
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
ThreadsCS-3013 C-term 2008 22
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 support• Re-opens old issues
• Deadlock detection
• Critical section management of synchronization primitives
ThreadsCS-3013 C-term 2008 23
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
ThreadsCS-3013 C-term 2008 24
Threading Issues
• Semantics of fork() and exec() system calls for processes
• Thread cancellation
• Signal handling
• Thread pools
• Thread specific data
• Scheduler activations
ThreadsCS-3013 C-term 2008 25
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
• Windows XP has something similar
ThreadsCS-3013 C-term 2008 26
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
ThreadsCS-3013 C-term 2008 27
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 signals1. Signal is generated by particular event2. Signal is delivered to a process3. 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 thread to receive all signals for the
process
ThreadsCS-3013 C-term 2008 28
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 the
application(s) to be bound to the size of the pool
ThreadsCS-3013 C-term 2008 29
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)
ThreadsCS-3013 C-term 2008 30
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;
};
ThreadsCS-3013 C-term 2008 31
Models for Kernel Implementation
• Many-to-One
• One-to-One
• Many-to-Many
ThreadsCS-3013 C-term 2008 32
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 ThreadFiber package
ThreadsCS-3013 C-term 2008 33
Many-to-Many Model
ThreadsCS-3013 C-term 2008 34
Two-level Model
• Similar to M:M, except that it allows a user thread to be bound to kernel thread
• Examples• IRIX
• HP-UX
• Tru64 UNIX
• Solaris 8 and earlier
ThreadsCS-3013 C-term 2008 35
Two-level Model
ThreadsCS-3013 C-term 2008 36
Many-to-One
• Many user-level threads mapped to single kernel thread
• Examples:• Solaris Green Threads
• GNU Portable Threads
ThreadsCS-3013 C-term 2008 37
Many-to-One Model
ThreadsCS-3013 C-term 2008 38
One-to-One
• Each user-level thread maps to kernel thread
• Examples• Windows NT/XP/2000
• Linux
• Solaris 9 and later
ThreadsCS-3013 C-term 2008 39
One-to-one Model
ThreadsCS-3013 C-term 2008 40
Modern Linux Threads
• Implemented in kernel• “A thread is just a special kind of process.”
• Robert Love, Linux Kernel Development, p.23
• The primary unit of scheduling and computation implemented by Linux 2.6 kernel
• Every thread has its own task_struct in kernel
• …
ThreadsCS-3013 C-term 2008 41
Modern Linux Threads (continued)
• Process task_struct has pointer to own memory & resources
• Thread task_struct has pointer to process’s memory & resources
• fork() and thread_create() are library functions implemented by clone() kernel call.
• …
ThreadsCS-3013 C-term 2008 42
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
ThreadsCS-3013 C-term 2008 43
Process Context
0x00000000
0xFFFFFFFF
Virtual
address space
code(text)
static data
heap
(dynamically allocated)
Kernel Code and Data
PC
SP
User Space
stack
(dynamically allocated)
Kernel Space
32-bit Linux & Win XP – 3G/1G user space/kernel space
ThreadsCS-3013 C-term 2008 44
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 or thread
• …
ThreadsCS-3013 C-term 2008 45
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
ThreadsCS-3013 C-term 2008 46
Reading Assignment
• Robert Love, Linux Kernel Development– Chapter 3 – “Process Management”
• Silbertshatz– Chapter 4 – “Threads”
ThreadsCS-3013 C-term 2008 47
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
ThreadsCS-3013 C-term 2008 48
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
ThreadsCS-3013 C-term 2008 49
Questions?