Unit II Threads

Chapter 4: Threads
Operating System Concepts – 8th Edition Silberschatz, Galvin and Gagne ©2009
Chapter 4: Threads
 Overview
 Multithreading Models
 Thread Libraries
 Threading Issues
 Operating System Examples
 Windows XP Threads
 Linux Threads
Operating System Concepts – 8th Edition 4.2 Silberschatz, Galvin and Gagne ©2009
Objectives
 To introduce the notion of a thread — a fundamental unit of CPU utilization that forms
the basis of multithreaded computer systems
 To discuss the APIs for the Pthreads, Win32, and Java thread libraries
 To examine issues related to multithreaded programming
Motivation
 Threads run within application
 Basic unit of CPU Utilization
 It comprises of Thread Id,PC, register set, stack
 Multiple tasks with the application can be implemented by separate
threads
 Update display
 Fetch data
 Spell checking
 Answer a network request
 Process creation is heavy-weight while thread creation is light-
weight
 Can simplify code, increase efficiency
 Kernels are generally multithreaded
Single and Multithreaded Processes
Benefits
 Responsiveness:
 Multithreading an interactive application may allow a program to
continue running even if part of it is blocked or is performing a
lengthy operation, thereby increasing responsiveness to the user
 Resource Sharing
 The benefit of sharing code and data is that it allows an
application to have several different threads of activity within the
same address space.
 Economy
 threads share the resources of the process to which they belong,
it is more economical to create and context-switch threads.
 Scalability : Multi Threading on multiple CPU increases parallelism
Multicore Programming
 Multicore systems putting pressure on programmers, challenges
include:
 Dividing activities: identifying areas that can be divided into
separate concurrent tasks.
 Balance: while identifying look for equal work equal value
tasks
 Data splitting: data accessed and manipulated by the tasks
must be divided
 Data dependency: should look for data dependencies
 Testing and debugging:
Multithreaded Server Architecture
Concurrent Execution on a
Single-core System
Parallel Execution on a
Multicore System
User Threads
 Thread management done by user-level threads library
 Three primary thread libraries:

 POSIX Pthreads
 Win32 threads
 Java threads
Kernel Threads
 Supported by the Kernel
 Examples
 Windows XP/2000
 Solaris
 Linux
 Tru64 UNIX
 Mac OS X
Multithreading Models
 Many-to-One
 One-to-One
 Many-to-Many
Many-to-One
 Many user-level threads mapped to single kernel thread
 Thread management is done by the thread library in the user space
 The entire process will block if a thread makes a blocking system
call
 Because only one thread can access the kernel at a time, multiple
threads are unable to run in parallel on multiprocessor system.
 Examples:
 Solaris Green Threads
 GNU Portable Threads
Many-to-One Model
One-to-One
 Each user-level thread maps to kernel thread
 Provides more concurrency than many to one, by allowing another
thread to run when a thread make a blocking system call
 Allows multiple threads to run in parallel on multiprocessor system.
 Creating a user thread requires creating a corresponding kernel

thread.
 Because the overhead of creating the kernel thread can burden the
performance of the application most implementations of this model
restrict the number of threads supported by the system
 Examples
 Windows NT/XP/2000
 Linux
 Solaris 9 and later
One-to-one Model
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
 When a thread performs a blocking system call, the kernel can

schedule another thread for execution.
 Solaris prior to version 9
 Windows NT/2000 with the ThreadFiber package
Many-to-Many Model
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
Two-level Model
Consider three processes, all arriving at time zero,
with total execution time of 10, 20 and 30 units,
respectively. Each process spends the first 20% of
execution time doing I/O, the next 70% of time
doing computation, and the last 10% of time doing
I/O again. The operating system uses a shortest
remaining compute time first scheduling algorithm
and schedules a new process either when the
running process gets blocked on I/O or when the
running process finishes its compute burst. Assume
that all I/O operations can be overlapped as much
as possible. For what percentage of time does the
CPU remain idle?

Unit II Threads

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unit II Threads

Uploaded by

Copyright:

Available Formats

Chapter 4: Threads

 To examine issues related to multithreaded programming

 Scalability : Multi Threading on multiple CPU increases parallelism

 Three primary thread libraries:

 Creating a user thread requires creating a corresponding kernel

 Allows many user level threads to be mapped to many kernel

 Allows the operating system to create a sufficient number of

 When a thread performs a blocking system call, the kernel can

 Solaris prior to version 9

 Windows NT/2000 with the ThreadFiber package

 Similar to M:M, except that it allows a user thread to be bound

You might also like