threads

Document Sample
threads Powered By Docstoc
					Threads


 Lecture 3




      Washington
 WASHINGTON UNIVERSITY IN ST LOUIS
                          Some Definitions
• Parallelism: degree to which a multiprocessor
  application achieves parallel execution
• Concurrency: Maximum parallelism an
  application can achieve with unlimited
  processors
• System Concurrency: kernel recognizes multiple
  threads of control in a program
• User Concurrency: User space threads
  (coroutines) to provide a natural programming
  model for concurrent applications. Concurrency
  not supported by system.


Fred Kuhns (11/30/2010)      CS523 – Operating Systems   2
                          Process and Threads
• Process: encompasses
    – set of threads (computational entities)
    – collection of resources
• Thread: Dynamic object representing an
  execution path and computational state.
    – threads have their own computational state: PC,
      stack, user registers and private data
    – Remaining resources are shared amongst threads
      in a process




Fred Kuhns (11/30/2010)        CS523 – Operating Systems   3
                           Threads
• Effectiveness of parallel computing depends on
  the performance of the primitives used to
  express and control parallelism
• Threads separate the notion of execution from
  the Process abstraction
• Useful for expressing the intrinsic concurrency
  of a program regardless of resulting
  performance
• Three types: User threads, kernel threads and
  Light Weight Processes (LWP)



Fred Kuhns (11/30/2010)   CS523 – Operating Systems   4
                             Threading Models
• User level threads - user libraries implementation
   – Benefits: no kernel modifications, flexible and low cost
   – Drawbacks: thread may block entire process, no parallelism
• Kernel level threads - kernel directly supports multiple threads of
  control in a process.
   – Benefits: scheduling/synchronization coordination, less overhead than
     process, suitable for parallel application
   – Drawbacks: more expensive than user-level threads, generality leads
     to greater overhead
• Light-Weight Processes (LWP) Kernel supported user thread
   –   LWP bound to kernel thread: a kernel thread may not be bound to an LWP
   –   LWP is scheduled by kernel
   –   User threads scheduled by library onto LWPs
   –   Multiple LWPs per process




   Fred Kuhns (11/30/2010)      CS523 – Operating Systems                  5
      First Class threads (Psyche OS)
• Thread operations in user space:
     – create, destroy, synch, context switch
• kernel threads implement a virtual processor
• Course grain in kernel - preemptive scheduling
• Communication between kernel and threads library
     – shared data structures.
     – Software interrupts (user upcalls or signals). Example, for
       scheduling decisions and preemption warnings.
     – Kernel scheduler interface - allows dissimilar thread packages
       to coordinate.




Fred Kuhns (11/30/2010)   CS523 – Operating Systems                6
                      Scheduler Activations
• An activation:
   – serves as execution context for running thread
   – notifies thread of kernel events (upcall)
   – space for kernel to save processor context of current
     user thread when stopped by kernel
• kernel is responsible for processor allocation =>
  preemption by kernel.
• Thread package responsible for scheduling
  threads on available processors (activations)




 Fred Kuhns (11/30/2010)    CS523 – Operating Systems   7
                     Support for Threading
• BSD:
    – process model only. 4.4 BSD enhancements.
• Solaris:provides
    – user threads, kernel threads and LWPs
• Mach: supports
    – kernel threads and tasks. Thread libraries provide
      semantics of user threads, LWPs and kernel threads.
• Digital UNIX: extends MACH to provide usual
  UNIX semantics.
    – Pthreads library.



 Fred Kuhns (11/30/2010)   CS523 – Operating Systems    8
                           Solaris Threads
• Supports:
   – user threads (uthreads) via libthread and libpthread
   – LWPs, acts as a virtual CPU for user threads
   – kernel threads (kthread), every LWP is associated
     with one kthread, however a kthread may not have an
     LWP
• interrupts as threads




 Fred Kuhns (11/30/2010)      CS523 – Operating Systems   9
                          Solaris kthreads

• Fundamental scheduling/dispatching object
• all kthreads share same virtual address space
  (the kernels) - cheap context switch
• System threads - example STREAMS, callout
• kthread_t, /usr/include/sys/thread.h
     – scheduling info, pointers for scheduler or sleep
       queues, pointer to klwp_t and proc_t




Fred Kuhns (11/30/2010)      CS523 – Operating Systems    10
                          Solaris LWP
• Bound to a kthread
• LWP specific fields from proc are kept in
  klwp_t (/usr/include/sys/klwp.h)
     – user-level registers, system call params, resource
       usage, pointer to kthread_t and proc_t
• klwp_t can be swapped with LWP
• LWP non-swappable info kept in kthread_t




Fred Kuhns (11/30/2010)    CS523 – Operating Systems        11
                           Solaris LWP (cont)
• All LWPs in a process share:
    – signal handlers
• Each may have its own
    – signal mask
    – alternate stack for signal handling
• No global name space for LWPs




 Fred Kuhns (11/30/2010)       CS523 – Operating Systems   12
                       Solaris User Threads
• Implemented in user libraries
• library provides synchronization and scheduling
  facilities
• threads may be bound to LWPs
• unbound threads compete for available LWPs
• Manage thread specific info
   – thread id, saved register state, user stack, signal
     mask, priority*, thread local storage
• Solaris provides two libraries: libthread and
  libpthread.
• Try man thread or man pthreads


 Fred Kuhns (11/30/2010)    CS523 – Operating Systems      13
       Solaris Thread Data Structures

                          proc_t
                            p_tlist
                                                                  kthread_t
                                                                   t_procp
                                                                     t_lwp
                      klwp_t                                        t_forw
                          lwp_thread
                          lwp_procp




Fred Kuhns (11/30/2010)               CS523 – Operating Systems               14
       Solaris: Processes, Threads and
                    LWPs
                   Process 1                                   Process 2



 user
                          L    L          L                        L       Int kthr




  kernel                                                                       ...
                                                                                 ...
                                                                                   ...


                                   P          P            P
   hardware


Fred Kuhns (11/30/2010)        CS523 – Operating Systems                                 15
                          Solaris Interrupts
• One system wide clock kthread
• pool of 9 partially initialized kthreads per CPU
  for interrupts
• interrupt thread can block
• interrupted thread is pinned to the CPU




Fred Kuhns (11/30/2010)       CS523 – Operating Systems   16
                  Solaris Signals and Fork
• Divided into Traps (synchronous) and
  interrupts (asynchronous)
• each thread has its own signal mask, global set
  of signal handlers
• Each LWP can specify alternate stack
• fork replicates all LWPs
• fork1 only the invoking LWP/thread




Fred Kuhns (11/30/2010)   CS523 – Operating Systems   17
                                   Mach
• Two abstractions:
   – Task - static object, address space and system
     resources called port rights.
   – Thread - fundamental execution unit and runs in
     context of a task.
         •   Zero or more threads per task,
         •   kernel schedulable
         •   kernel stack
         •   computational state
• Processor sets - available processors divided into non-
  intersecting sets.
   – permits dedicating processor sets to one or more tasks




 Fred Kuhns (11/30/2010)      CS523 – Operating Systems       18
       Mach c-thread Implementations
• Coroutine-based - multiples user threads
  onto a single-threaded task
• Thread-based - one-to-one mapping from c-
  threads to Mach threads. Default.
• Task-based - One Mach Task per c-thread.




Fred Kuhns (11/30/2010)   CS523 – Operating Systems   19
                          Digital UNIX
• Based on Mach 2.5 kernel
• Provides complete UNIX programmers
  interface
• 4.3BSD code and ULTRIX code ported to Mach
   – u-area replaced by utask and uthread
   – proc structure retained




Fred Kuhns (11/30/2010)    CS523 – Operating Systems   20
                       Digital UNIX threads
• Signals divided into synchronous and
  asynchronous
• global signal mask
• each thread can define its own handlers for
  synchronous signals
• global handlers for asynchronous signals




 Fred Kuhns (11/30/2010)    CS523 – Operating Systems   21
                           Pthreads library
• One Mach thread per pthread
• implements asynchronous I/O
   – separate thread created for synchronous I/O which
     in turn signals original thread
• library includes signal handling, scheduling
  functions, and synchronization primitives.




 Fred Kuhns (11/30/2010)      CS523 – Operating Systems   22
                          Mach Continuations
• Address problem of excessive kernel stack memory
  requirements
• process model versus interrupt model
     – one per process kernel stack versus a per thread kernel
       stack
• Thread is first responsible for saving any required
  state (the thread structure allows up to 28 bytes)
• indicate a function to be invoked when unblocked (the
  continuation function)
• Advantage: stack can be transferred between
  threads eliminating copy overhead.



Fred Kuhns (11/30/2010)       CS523 – Operating Systems          23
                    Threads in Windows NT
• Design driven by need to support a variety of
  OS environments
• NT process implemented as an object
• executable process contains >= 1 thread
• process and thread objects have built in
  synchronization capabilitiesS




 Fred Kuhns (11/30/2010)   CS523 – Operating Systems   24
                           NT Threads
• Support for kernel (system) threads
• Threads are scheduled by the kernel and thus
  are similar to UNIX threads bound to an LWP
  (kernel thread)
• fibers are threads which are not scheduled by
  the kernel and thus are similar to unbound user
  threads.




 Fred Kuhns (11/30/2010)    CS523 – Operating Systems   25
                           4.4 BSD UNIX
• Initial support for threads implemented but
  not enabled in distribution
• Proc structure and u-area reorganized
• All threads have a unique ID
• How are the proc and u areas reorganized to
  support threads?




 Fred Kuhns (11/30/2010)     CS523 – Operating Systems   26

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:10
posted:11/30/2010
language:English
pages:26