Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out
Get this document free

threads

VIEWS: 3 PAGES: 9

									                              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 (9/4/2003)        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 (9/4/2003)        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 (9/4/2003)      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 (9/4/2003)      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 (9/4/2003)      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 (9/4/2003)      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 (9/4/2003)      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 (9/4/2003)      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 (9/4/2003)       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
          - wappable info kept in kthread_t
 • LWP non s




 Fred Kuhns (9/4/2003)       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 (9/4/2003)       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 (9/4/2003)               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 (9/4/2003)               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 (9/4/2003)               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 (9/4/2003)       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 (9/4/2003)       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 (9/4/2003)       CS523 – Operating Systems       18
       Mach c-thread Implementations
            - ased- multiples user threads
 • Coroutine b
               - t
   onto a single hreaded task
         - ased - one t o mapping from -
 • Thread b             o
                     - - ne                c
   threads to Mach threads. Default.
      - ased- One Mach Task per - t
 • Task b                           c hread.




 Fred Kuhns (9/4/2003)    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 (9/4/2003)    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 (9/4/2003)    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 (9/4/2003)       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 (9/4/2003)       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 (9/4/2003)       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 (9/4/2003)     CS523 – Operating Systems   25




                         4.4 BSD UNIX
• Initial support for threads implemented but
  not enabled in distribution
                      u rea
• Proc structure and - a reorganized
• All threads have a unique ID
• How are the proc and u areas reorganized to
  support threads?




 Fred Kuhns (9/4/2003)     CS523 – Operating Systems   26

								
To top