Chapter 4: Multithreaded

Programming

Operating System Concepts – 9th Edition Silberschatz, Galvin and Gagne ©2013
 Chapter 4: Multithreaded Programming
Overview
Multicore Programming
Multithreading Models
Thread Libraries
Implicit Threading
Threading Issues
Operating System Examples

Operating System Concepts – 9th Edition 4.2 Silberschatz, Galvin and Gagne ©2013
 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, Windows, and Java thread libraries

To explore several strategies that provide implicit threading

To examine issues related to multithreaded programming

To cover operating system support for threads in Windows and Linux

Operating System Concepts – 9th Edition 4.3 Silberschatz, Galvin and Gagne ©2013
 Motivation
A thread in computer science is short for a thread of execution. Threads are a way
for a program to divide (termed "split") itself into two or more simultaneously (or
pseudo-simultaneously) running tasks.

Most modern applications are multithreaded

Threads run within application
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

Operating System Concepts – 9th Edition 4.4 Silberschatz, Galvin and Gagne ©2013
 Thread
Concept
◼ Single threaded
◼ Multithreaded application
application

int main(){ int main(){ int th1(){

.. f1(); .. f2(); ……
printf(`Done\n`); printf(`Done\n`);
} } }

int f1(){ int f2(){ int th2(){

…… …… ……
return result; return result; }
} }

Operating System Concepts – 9th Edition 4.5 Silberschatz, Galvin and Gagne ©2013
 Single and Multithreaded Processes

Operating System Concepts – 9th Edition 4.6 Silberschatz, Galvin and Gagne ©2013
 Multithreaded Server Architecture

Operating System Concepts – 9th Edition 4.7 Silberschatz, Galvin and Gagne ©2013
 Benefits

Responsiveness – may allow continued execution if part of process is blocked,

especially important for user interfaces

Resource Sharing – threads share resources of process, easier than shared

memory or message passing

Economy – cheaper than process creation, thread switching lower overhead than
context switching

Scalability – process can take advantage of multiprocessor architectures

Operating System Concepts – 9th Edition 4.8 Silberschatz, Galvin and Gagne ©2013
 Resource Sharing
All of the process’ threads share the same memory and open files.
Within the shared memory, each thread gets its own stack.
Each thread has its own instruction pointer and registers.
OS has to keep track of processes, and stored its per-process information in a
data structure called a process control block (PCB).
A multithread-aware OS also needs to keep track of threads.
The items that the OS must store that are unique to each thread are:
Thread ID
Saved registers, stack pointer, instruction pointer
Stack (local variables, temporary variables, return addresses)
Signal mask
Priority (scheduling information)

Operating System Concepts – 9th Edition 4.9 Silberschatz, Galvin and Gagne ©2013
 Multicore Programming

Multicore or multiprocessor systems putting pressure on programmers,

challenges include:
Dividing activities
Balance
Data splitting
Data dependency
Testing and debugging
Parallelism implies a system can perform more than one task simultaneously
Concurrency supports more than one task making progress
Single processor / core, scheduler providing concurrency

Operating System Concepts – 9th Edition 4.10 Silberschatz, Galvin and Gagne ©2013
 Concurrency vs. Parallelism
Concurrent execution on single-core system:

Parallelism on a multi-core system:

Operating System Concepts – 9th Edition 4.11 Silberschatz, Galvin and Gagne ©2013
 Multicore Programming

Types of parallelism
Data parallelism – distributes subsets of the same data
across multiple cores, same operation on each
Task parallelism – distributing threads across cores, each
thread performing unique operation

Operating System Concepts – 9th Edition 4.12 Silberschatz, Galvin and Gagne ©2013
 Data and Task Parallelism

Operating System Concepts – 9th Edition 4.13 Silberschatz, Galvin and Gagne ©2013
 Professor P

15 questions
300 exams

Copyright © 2010, Elsevier Inc. All rights Reserved

Operating System Concepts – 9th Edition 4.14 Silberschatz, Galvin and Gagne ©2013
 Professor P’s grading assistants

TA#1
Copyright © 2010, Elsevier Inc. All rights Reserved
TA#2 TA#3

Operating System Concepts – 9th Edition 4.15 Silberschatz, Galvin and Gagne ©2013
 Division of work – data parallelism

TA#1

TA#3

100 exams

100 exams

TA#2

100 exams

Copyright © 2010, Elsevier Inc. All rights Reserved

Operating System Concepts – 9th Edition 4.16 Silberschatz, Galvin and Gagne ©2013
 Division of work – task parallelism

TA#1

TA#3

Questions 11 - 15
Questions 1 - 5

TA#2

Questions 6 - 10

Copyright © 2010, Elsevier Inc. All rights Reserved

Operating System Concepts – 9th Edition 4.17 Silberschatz, Galvin and Gagne ©2013
 Amdahl’s Law
Identifies performance gains from adding additional cores to an application that has
both serial and parallel components
S is serial portion
N processing cores

I.e. if application is 75% parallel / 25% serial, moving from 1 to 2 cores results in
speedup of

1 / ( 0.25 + 0.75 / 2 ) = 1 / 0.625 = 1.6 times

Operating System Concepts – 9th Edition 4.18 Silberschatz, Galvin and Gagne ©2013
 Example
We can parallelize 90% of a serial program.
Parallelization is “perfect” regardless of the number of cores p we use.
Tserial = 20 seconds
Runtime of parallelizable part is

0.9 x Tserial / p = 18 / p

Copyright © 2010, Elsevier Inc. All rights Reserved

Operating System Concepts – 9th Edition 4.19 Silberschatz, Galvin and Gagne ©2013
 Example (cont.)
Runtime of “unparallelizable” part is

0.1 x Tserial = 2
Overall parallel run-time is

Tparallel = 0.9 x Tserial / p + 0.1 x Tserial = 18 / p + 2

Copyright © 2010, Elsevier Inc. All rights Reserved

Operating System Concepts – 9th Edition 4.20 Silberschatz, Galvin and Gagne ©2013
 Example (cont.)
Speed up

Tserial 20
=
S=
0.9 x Tserial / p + 0.1 x Tserial 18 / p + 2

If p =10;
20 / 3.8 = ~5.25x speed up

Copyright © 2010, Elsevier Inc. All rights Reserved

Operating System Concepts – 9th Edition 4.21 Silberschatz, Galvin and Gagne ©2013
 Amdahl’s Law

As N approaches infinity, speedup approaches 1 / S

Serial portion of an application has disproportionate effect on performance
gained by adding additional cores

But does the law take into account contemporary multicore systems?

Operating System Concepts – 9th Edition 4.22 Silberschatz, Galvin and Gagne ©2013
 User and Kernel Threads

Operating System Concepts – 9th Edition 4.23 Silberschatz, Galvin and Gagne ©2013
 User Threads and Kernel Threads
User threads - management done by user-level threads library
Three primary thread libraries:
POSIX Pthreads
Win32 threads
Java threads

Kernel threads - Supported by the Kernel

Examples – virtually all general purpose operating systems, including:
Windows
Solaris
Linux
Tru64 UNIX
Mac OS X

Operating System Concepts – 9th Edition 4.24 Silberschatz, Galvin and Gagne ©2013
 Multithreading Models
Many-to-One

One-to-One

Many-to-Many

Operating System Concepts – 9th Edition 4.25 Silberschatz, Galvin and Gagne ©2013
 Many-to-One

Many user-level threads mapped to single kernel thread

One thread blocking causes all to block
Multiple threads may not run in parallel on muticore system
because only one may be in kernel at a time
Few systems currently use this model
Examples:
Solaris Green Threads
GNU Portable Threads

Operating System Concepts – 9th Edition 4.26 Silberschatz, Galvin and Gagne ©2013
 One-to-One
Each user-level thread maps to kernel thread
Creating a user-level thread creates a kernel thread
More concurrency than many-to-one
Number of threads per process sometimes restricted due to overhead

Examples
Windows NT/XP/2000
Linux
Solaris 9 and later

Operating System Concepts – 9th Edition 4.27 Silberschatz, Galvin and Gagne ©2013
 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

Operating System Concepts – 9th Edition 4.28 Silberschatz, Galvin and Gagne ©2013
 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

Operating System Concepts – 9th Edition 4.29 Silberschatz, Galvin and Gagne ©2013
 Thread Libraries
Thread library provides programmer with API for creating and managing
threads

Two primary ways of implementing

Library entirely in user space
Kernel-level library supported by the OS

Operating System Concepts – 9th Edition 4.30 Silberschatz, Galvin and Gagne ©2013
 POSIX threads (Pthreads)
◼ A POSIX standard (IEEE 1003.1c) API for thread creation and synchronization

◼ Specification, not implementation

◼ May be provided either as user-level or kernel-level

◼ API specifies behavior of the thread library, implementation is up to

development of the library

◼ Common in UNIX operating systems (Solaris, Linux, Mac OS X)

Operating System Concepts – 9th Edition 4.31 Silberschatz, Galvin and Gagne ©2013
 Pthreads Example
#include <pthread.h> /* The thread function */
#include <stdio.h>
void *runner(void *param)
int sum; /* this data is shared by the thread(s) */ {
void *runner(void *param); /* the thread function*/ int i, upper = atoi(param);
sum = 0;
int main (int argc, char *argv[])
{ if (upper > 0) {
pthread_t tid; /* the thread identifier */ for (i = 1; i <= upper; i++) sum
pthread_attr_t attr; /*attributes for the thread */ += i;
}
/* get the default attributes */
pthread_attr_init(&attr); pthread_exit(0);
}
/* create the thread*/
pthread_create(&tid,&attr,runner,argv[1]);

/* now wait for the thread to exit */

pthread_join(tid,NULL);

printf("sum = %d\n",sum);
}

Operating System Concepts – 9th Edition 4.32 Silberschatz, Galvin and Gagne ©2013
 Pthreads Code for Joining 10 Threads

#include <pthread.h> /* The thread function */

#include <stdio.h>
void *runner(void *param)
int sum; /* this data is shared by the thread(s) */ {
void *runner(void *param); /* the thread */ int i, upper = atoi(param);
#define NUM_THREADS 10
if (upper > 0) {
int main (int argc, char *argv[]) for (i = 1; i <= upper; i++) sum
{ += i;
int i; }
pthread_t workers[NUM_THREADS]; /* the thread array*/
pthread_attr_t attr; /*attributes for the threads */ pthread_exit(0);
}
sum = 0;
/* get the default attributes */
pthread_attr_init(&attr);

/* create the thread*/

for (i=0; i<NUM_THREADS; i++)
pthread_create(&worker[i], &attr,runner, i+1);

/* now wait for the thread to exit */ for (i=0;

i<NUM_THREADS; i++)
pthread_join(worker[i] ,NULL);

printf("sum = %d\n",sum);
}

Operating System Concepts – 9th Edition 4.33 Silberschatz, Galvin and Gagne ©2013
 Windows Multithreaded C Program (Cont.)

Operating System Concepts – 9th Edition 4.34 Silberschatz, Galvin and Gagne ©2013
 Windows Multithreaded C Program

Operating System Concepts – 9th Edition 4.35 Silberschatz, Galvin and Gagne ©2013
 Java Threads
Java threads are managed by the JVM

Typically implemented using the threads model provided by underlying OS

Java threads may be created by:

Extending Thread class

Implementing the Runnable interface

Operating System Concepts – 9th Edition 4.36 Silberschatz, Galvin and Gagne ©2013
 Java Multithreaded Program
public class Driver class Sum
{ {
public static void main(String[] args) { private int sum;
Sum sumObject = new Sum();
public int get() {
int upper = Integer.parseInt(args[0]);
return sum;
Thread worker = new Thread(new }
Summation(upper, sumObject)); worker.start();
try { public void set(int sum) {
worker.join(); this.sum = sum;
System.out.println("The sum of " + upper + " is " + }
sumObject.get()); }
} catch (InterruptedException ie) { }
} class Summation implements Runnable
} {
private int upper; private Sum sumValue;

public Summation(int upper, Sum sumValue) {

this.upper = upper;
this.sumValue = sumValue;
}

public void run() {

int sum = 0;
for (int i = 0; i <= upper; i++)
sum += i;
sumValue.set(sum);
}

}
Operating System Concepts – 9th Edition 4.37 Silberschatz, Galvin and Gagne ©2013
 Implicit Threading
Growing in popularity as numbers of threads increase, program correctness
more difficult with explicit threads
Creation and management of threads done by compilers and run-time libraries
rather than programmers

Three methods explored

Thread Pools
OpenMP
Grand Central Dispatch

Other methods include Microsoft Threading Building Blocks (TBB),

java.util.concurrent package

Operating System Concepts – 9th Edition 4.38 Silberschatz, Galvin and Gagne ©2013
 Thread Pools
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
Separating task to be performed from mechanics of creating task allows different
strategies for running task
 i.e.Tasks could be scheduled to run periodically

Windows API supports thread pools:

Operating System Concepts – 9th Edition 4.39 Silberschatz, Galvin and Gagne ©2013
 OpenMP
Set of compiler directives and an API for C,
C++, FORTRAN
Provides support for parallel programming in
shared-memory environments
Identifies parallel regions – blocks of code
that can run in parallel

#pragma omp parallel

Create as many threads as there are cores

#pragma omp parallel for

for(i=0;i<N;i++) {
c[i] = a[i] + b[i];
}
Run for loop in parallel

Operating System Concepts – 9th Edition 4.40 Silberschatz, Galvin and Gagne ©2013
 Grand Central Dispatch
Apple technology for Mac OS X and iOS operating systems
Extensions to C, C++ languages, API, and run-time library
Allows identification of parallel sections
Manages most of the details of threading
Block is in “^{ }” - ˆ{ printf("I am a block"); }
Blocks placed in dispatch queue
Assigned to available thread in thread pool when removed from queue
Two types of dispatch queues:
serial – blocks removed in FIFO order, queue is per process, called main queue
 Programmers can create additional serial queues within program
concurrent – removed in FIFO order but several may be removed at a time
 Three system wide queues with priorities low, default, high

Operating System Concepts – 9th Edition 4.41 Silberschatz, Galvin and Gagne ©2013
 Threading Issues

Semantics of fork() and exec() system calls

Signal handling
Synchronous and asynchronous

Thread cancellation of target thread

Asynchronous or deferred

Thread-local storage

Operating System Concepts – 9th Edition 4.42 Silberschatz, Galvin and Gagne ©2013
 Semantics of fork() and exec()
Does fork()duplicate only the calling thread or all threads?
Some UNIXes have two versions of fork
Exec() usually works as normal – replace the running process including all threads

Operating System Concepts – 9th Edition 4.43 Silberschatz, Galvin and Gagne ©2013
 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 signals

1. Signal is generated by particular event
2. Signal is delivered to a process
3. Signal is handled by one of two signal handlers:
1. default
2. user-defined

Every signal has default handler that kernel runs when handling signal
User-defined signal handler can override default
For single-threaded, signal delivered to process

Where should a signal be delivered for multi-threaded?

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

Operating System Concepts – 9th Edition 4.44 Silberschatz, Galvin and Gagne ©2013
 Thread Cancellation
Terminating a thread before it has finished
Thread to be canceled is target thread
Two general approaches:
Asynchronous cancellation terminates the target thread immediately
Deferred cancellation allows the target thread to periodically check if it
should be cancelled

Pthread code to create and cancel a thread:

Operating System Concepts – 9th Edition 4.45 Silberschatz, Galvin and Gagne ©2013
 Thread Cancellation (Cont.)

Invoking thread cancellation requests cancellation, but actual cancellation

depends on thread state

If thread has cancellation disabled, cancellation remains pending until thread

enables it
Default type is deferred
Cancellation only occurs when thread reaches cancellation point
 I.e. pthread_testcancel()
 Then cleanup handler is invoked
On Linux systems, thread cancellation is handled through signals

Operating System Concepts – 9th Edition 4.46 Silberschatz, Galvin and Gagne ©2013
 Thread-Local Storage
◼ Thread-local storage (TLS) allows each thread to have its
own copy of data

◼ Different from local variables

⚫ Local variables visible only during single function
invocation
⚫ TLS visible across function invocations

◼ Similar to static data

⚫ TLS is unique to each thread

◼ Useful when you do not have control over the thread creation
process (i.e., when using a thread pool)

Operating System Concepts – 9th Edition 4.47 Silberschatz, Galvin and Gagne ©2013
 Thanks for listening!

Operating System Concepts 4.4 Silberschatz, Galvin and

– 9th System
Edition Concepts – 9th Edition 8
4.48
Gagne ©2013
Silberschatz, Galvin and Gagne ©2013
Operating