Threads continued

1
Threads (continued)

• 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)

2
Review

• Threads introduced because
• Processes are heavyweight in Windows and Linux
• Difficult to develop concurrent applications when
  address space is unique per process
• Thread a particular execution of a program
  within the context of a Windows-Unix-Linux
  process
• Multiple threads in same address space at same
  time

3
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)

4
Characteristics

• 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

5
Address Space for Multiple Threads
thread 1 stack
SP (T1)
0xFFFFFFFF
thread 2 stack
SP (T2)
SP
thread 3 stack
SP (T3)
Virtual address space
heap
static data
0x00000000
code (text)
PC
PC (T2)
PC (T1)
PC (T3)
6
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

7
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

8
Reading Assignment

• Silbertshatz
• Chapter 4 Threads
• Robert Love, Linux Kernel Development
• Chapter 3 Process Management

9
Kernel Threads

• Supported by the Kernel
• OS maintains data structures for thread state and
  does all of the work of thread implementation.
• Examples
• Solaris
• Tru64 UNIX
• Mac OS X
• Windows 2000/XP/Vista
• Linux version 2.6

10
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

11
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 thread support
• Re-opens old issues
• Deadlock detection
• Critical section management of synchronization
  primitives (especially in OS kernel)

12
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

13
POSIX pthread Interface

• Data type pthread_t
• 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

14
Threads and small operating systems

• Many small operating systems provide a common
  address space for all concurrent activities
• Each concurrent execution is like a Linux-Unix
  thread
• But its often called a process!
• pthread interface and tools frequently used for
  managing these processes

15
Java Threads

• Thread class
• Thread worker new Thread()
• Configure it
• Run it
• public class application extends Thread
• Methods to
• Run, wait, exit
• Cancel, join
• Synchronize

16
Threading Issues

• Semantics of fork() and exec() system calls for
  processes
• Thread cancellation
• Signal handling
• Kernel thread implementations
• Thread pools
• Thread specific data
• Scheduler activations

17
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 only
  forking thread is created in child process
• Windows XP has something similar

18
Thread Cancellation

• Terminating a thread before it has finished
• Reason
• Some other thread may have completed the joint
  task
• E.g., searching a database
• Issue
• Other threads may be depending cancelled thread
  for resources, synchronization, etc.
• May not be able to cancel one until all can be
  cancelled

19
Thread Cancellation (continued)

• Two general approaches
• Asynchronous cancellation terminates the target
  thread immediately
• Deferred cancellation allows the target thread to
  periodically check if it should cancel itself
• pthreads provides cancellation points

20
Signal Handling

• Signals are used in Unix-Linux to notify process
  that a particular event has occurred e.g.
• Divide-by-zero
• Illegal memory access, stack overflow, etc.
• CTL-C typed, or kill command issued at console
• Timer expiration external alarm
• A signal handler is used to process signals
• Signal is generated by particular event
• Signal is delivered to a process
• Signal is handled by a signal handler
• All processes provided with default signal
  handler
• Applications may install own handlers for
  specific signals

21
Signal Handling Options

• Deliver signal to specific thread to which it
  applies
• E.g., illegal memory access, divide-by-zero, etc.
• Deliver signal to every thread in the process
• CTL-C typed
• Deliver signal to certain threads in the process
• I.e., threads that have agreed to receive such
  signals(or not blocked them)
• Assign a specific thread to receive all signals
  for the process

22
Kernel Thread Implementations

• Linux
• Windows
• Others

23
Modern Linux Thread Implementation

• Implemented directly in kernel
• Primary unit of scheduling and computation
  implemented by Linux 2.6 kernel
• A thread is just a special kind of process.
• Robert Love, Linux Kernel Development, p.23
• Every thread has its own task_struct in kernel

24
Definition

• Task (from point of view of Linux kernel)
• Process
• Thread
• Kernel thread (see later)

25
Modern Linux Threads (continued)

• Process task_struct has pointer to own memory
  resources
• Thread task_struct has pointer to processs
  memory resources
• Kernel thread task_struct has null pointer to
  memory resources
• fork() and pthread_create() are library functions
  that invoke clone() system call
• Arguments specify what kind of clone

26
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

27
Process Context
Kernel Code and Data
stack (dynamically allocated)
stack (dynamically allocated)
heap (dynamically allocated)
static data
PC
code (text)
32-bit Linux Win XP 3G/1G user space/kernel
space
28
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 address
  space on behalf of thread

29
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

30
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

31
Other Implementations of Kernel Threads

• Many-to-Many
• Many-to-One
• One-to-One

32
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 application(s) to
  be bounded by size of pool

33
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 Thread/Fiber package

34
Many-to-Many Model
35
Two-level Model

• Similar to MM, except it allows a specific
  thread to be bound to one kernel thread
• Examples
• IRIX
• HP-UX
• Tru64 UNIX
• Solaris 8 and earlier

36
Two-level Model
37
Many-to-One

• Many user-level threads mapped to single kernel
  thread
• Examples
• Solaris Green Threads
• GNU Portable Threads

38
Many-to-One Model
39
One-to-One

• Each user-level thread maps to kernel thread
• Examples
• Windows NT/XP/2000
• Linux
• Solaris 9 and later

40
One-to-one Model
41
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

42
Reading Assignment

• Silbertshatz
• Chapter 4 Threads
• Robert Love, Linux Kernel Development
• Chapter 3 Process Management

43
Questions?