CMP320
Operating Systems
Lecture 09, 10
Operating System Concepts
October 12, 14 2009
Arif Butt
Note:
Some slides and/or pictures are adapted from Lecture slides / Books of
•
Dr Mansoor Sarwar.
•
Dr Kubiatowicz.
•
Dr P. Bhat.
•
Dr Hank Levy.
•
Dr Indranil Gupta.
•
Text Book
-
OS Concepts by Silberschatz, Galvin, and Gagne.
•
Ref Books
•
Operating Systems Design and Implementation by Tanenbaum.
•
Operating Systems by William Stalling.
•
Operating Systems by Colin Ritchie.
Today’s Agenda
•
Review of previous lecture
•
Introduction to Threads
•
Multi threading and Hyper threading
•
Merits and Demerits of Threads
•
User Level vs Kernel Level Threads
•
Threading Models
–
Many to One
–
One to One
–
Many to Many
•
Parallel Processor Architectures
•
Using POSIX pthread library calls to create multi
-
threaded programs
2
CMP320 PUCIT Arif Butt
11/18/2013
Issues with Processes
3
CMP320 PUCIT Arif Butt
11/18/2013
The fork() system call is expensive, copying
the entire parent process as child process
It may not always be required to copy
entire parent process to child process as
the child is going to call
exec()
system call
immediately in most of the cases
IPC is required to pass information between
a parent and its child processes
•
Processes have two characteristics:
–
Resource ownership
-
process includes a virtual
address space to hold the process image
–
Scheduling/execution
-
follows an execution path
that may be interleaved with other processes
•
These two characteristics are treated
independently by the operating system
•
The unit of dispatching is referred to as a
thread
or lightweight process
•
The unit of resource ownership is referred
to as a
process
or
task
Processes and Threads
11/18/2013
4
CMP320 PUCIT Arif Butt
Thread Concept
5
CMP320 PUCIT Arif Butt
11/18/2013
A thread is a “lightweight”
process which executes within the
address space of a process
A thread is an execution context
that is independently scheduled,
but shares single addresses space
with other threads of the same
process
6
CMP320 PUCIT Arif Butt
11/18/2013
main()
{
…
f1(…);
…
f2(…);
…
}
f1(…)
{ … }
f2(…)
{ … }
Thread
Process
Terminated
f2
f1
Single Threaded Process
Thread Concept (cont…)
7
CMP320 PUCIT Arif Butt
11/18/2013
Previous slide is an example of a process with a single
thread
Suppose we want that f1 and f2 should be executed by
separate threads, while main function is executed
concurrently by another thread
Multi threading refers to the ability of an OS to
support multiple threads of execution with in a single
process.
A single program made up of a number of
different concurrent activities; sometimes called
multitasking, as in
Ada
Multithreading works similar to multiprogramming. The
CPU switches rapidly back and forth among threads
providing the illusion that threads are running in parallel
Multi Threaded Process
8
CMP320 PUCIT Arif Butt
11/18/2013
main()
{
…
thread(t1,f1);
…
thread(t2,f2);
…
}
f1(…)
{ … }
f2(…)
{ … }
main
t2
t1
Process Address Space
PC
PC
PC
Single and Multithreaded Processes
9
CMP320 PUCIT Arif Butt
11/18/2013
(a) Three processes, each with one thread
(b) One process with three threads
execution
Environment (resource)
Processes are used to group resources together; Threads are the
entities scheduled for execution on the CPU.
Single and Multithreaded Processes
10
CMP320 PUCIT Arif Butt
11/18/2013
Single and Multithreaded Processes
11/18/2013
11
CMP320 PUCIT Arif Butt
Thread Concept
12
CMP320 PUCIT Arif Butt
11/18/2013
Single and Multithreaded Processes
13
CMP320 PUCIT Arif Butt
11/18/2013
•
Each thread stack contains one frame for each procedure that has been called but not yet
returned from
•
This frame contains the procedure’s local variables and their return address to use when
the procedure call has finished
•
For example, if procedure X calls procedure Y and this one calls procedure Z, while Z is
executing the frames for X, Y, Z will be on the stack
•
Each thread will generally call different procedures and thus has a different execution
history
Each Thread has its own Stack
Threads
vs
Processes
14
CMP320 PUCIT Arif Butt
11/18/2013
Similarities
A thread can also be in one of many states like new,
ready, running, blocked, terminated
Like processes only one thread is in running state
(single CPU)
Like processes a thread can create a child thread
Differences
No “automatic” protection mechanism is in place for
threads
—
they are meant to help each other
Every process has its own address space, while all
threads within a process operate within the same
address space
Benefits of Threads
15
CMP320 PUCIT Arif Butt
11/18/2013
Responsiveness.
Multi
-
threaded servers (e.g., browsers)
can allow interaction with user while a thread is formulating
response to a previous user query (e.g., rendering a web page)
Resource sharing.
Process resources (code, data, etc.)
are shared by all threads. OS resources (PCB, PPFDT, etc.) are
also shared by all threads
Economy.
Take less time to create, schedule, and
terminate a thread.
Solaris 2
: Thread Creation is
thirty
times
faster than Process Creation and Thread Switching is
five
times faster than process switching
Performance
. In multi
-
processor and multi
-
threaded
architectures (e.g., Intel’s P
-
IV HT) each thread may run on a
different processor in parallel
Disadvantages of Threads
16
CMP320 PUCIT Arif Butt
11/18/2013
Problems due to Shared memory
Race Problem
Mutual Exclusion
needs to be implemented on shared
memory to allow multiple threads to access data for
write/update
Many library functions are not Thread Safe
For resource sharing, synchronization is needed
between threads
Lack of Robustness
A severe error caused by one thread (e.g. segmentation
fault) terminates the whole process
Problems with Threads
17
CMP320 PUCIT Arif Butt
11/18/2013
1.
Consider the effects of the fork() system
call, when the parent process has multiple
threads, should the child also have those
multiple threads?
•
If not, the process may not function properly,
since all of them may be essential
•
If yes, what happens if a thread was blocked on
reading the keyboard? Are two threads now
blocked on the keyboard? When a line is typed,
do both threads get a copy of it? Only the
parent? Only the child?
Problems with Threads (cont…)
18
CMP320 PUCIT Arif Butt
11/18/2013
2. Another class of problems is related to the
fact that threads share many data
structures:
•
What happens if one thread closes a file while
another one is still reading from it?
•
What happens when one thread feels that there
is too little memory and starts allocating more
memory, soon afterwards another thread of the
same process executes and do the same. Does
the allocation happen once or twice?
Problems with Threads (cont…)
19
CMP320 PUCIT Arif Butt
11/18/2013
3.
Error Reporting
: In UNIX, after a system call ,the
status of the call is put into a global variable,
errno
. What happens if a thread makes a system
call, and before it is able to read
errno
, another
thread makes a system call, wiping out the original
value?
4.
Stack Management
: When stack overflow occurs, the
kernel just provides more stack, automatically. When
a process has multiple threads, it must also have
multiple stacks. If the kernel is not aware of all
these stacks, it cannot grow them automatically upon
stack fault. In fact, it may not even realize that a
memory fault is related to stack growth
Thread Usage: Word Processor
20
CMP320 PUCIT Arif Butt
11/18/2013
•
What will happen when a user deletes one line from
page#1 of a 800 page document and immediately after
that to make a change on page#600, gives a command
telling the word processor to go to that page.
Reformatting thread
A thread that interacts with user
A thread that handles
disk back ups; writes
contents of RAM to disk
periodically.
Thread Usage: Web Server
21
•
Dispatcher thread reads incoming requests from the NW.
•
After examining the request, it chooses an idle worker thread and hands it the
request. It also wakes up the worker from blocked state to ready state.
•
Worker now checks to see if the request can be satisfied from the Web page
cache, to which all threads have access. If not, it starts a read() operation to
get the page from the disk and blocks until the disk operation completes. When
the thread blocks on the disk operation, another thread is chosen to run,
possibly the dispatcher, in order to acquire more work, or possibly another
worker that is now ready to run.
Request for pages
comes in and the
requested page is
sent back to the
client.
11/18/2013
CMP320 PUCIT Arif Butt
Thread Usage: Web Server (cont…)
22
CMP320 PUCIT Arif Butt
11/18/2013
Rough outline of code for previous slide
Dispatcher Thread
Worker Thread
Classification
•
Real operating systems have either
–
One or many address spaces
–
One or many threads per address space
Mach, OS/2, Linux
Win NT to XP, Solaris, HP
-
UX, OS X
Embedded systems
(Geoworks, VxWorks,
JavaOS,etc)
JavaOS, Pilot(PC)
Traditional UNIX
MS/DOS, early Macintosh
Many
One
# threads
Per AS:
Many
One
# of addr
spaces:
11/18/2013
23
CMP320 PUCIT Arif Butt
Multithreading
•
The ability of an
OS to support
multiple,
concurrent paths
of execution
within a single
process.
11/18/2013
24
CMP320 PUCIT Arif Butt
Single Thread Approaches
•
MS
-
DOS supports a
single user process
and a single thread.
•
Some UNIX,
support multiple
user processes but
only support one
thread per process
11/18/2013
25
CMP320 PUCIT Arif Butt
Multithreading
•
Java run
-
time
environment is a
single process with
multiple threads
•
Multiple processes
and
threads are
found in Windows,
Solaris, and many
modern versions of
UNIX
11/18/2013
26
CMP320 PUCIT Arif Butt
User Threads
27
CMP320 PUCIT Arif Butt
11/18/2013
Thread management is done by user
-
level threads
libraries (
eg
, POSIX
Pthread
, Win32 threads, Java
threads, Solaris2 Threads, Mach C Threads) and
Kernel is not aware of the existence of threads
An application can be programmed to be multithreaded
by using user level thread library, which contains code
for:
Thread creation and termination
Thread scheduling
Saving and restoring thread context
Passing messages and data between threads
By default an application begins with a single thread,
within a process managed by Kernel. Later the
application may spawn a new thread within the same
process by invoking spawn utility in the thread library
Implementing Threads in User Space
28
CMP320 PUCIT Arif Butt
11/18/2013
User
-
level Threads
•
Thread library used.
•
Thread table
maintained in
user space.
•
All thread management is
done in user space by library
•
Kernel knows nothing about
threads.
E.g.: pthread library
Kernel Threads
29
CMP320 PUCIT Arif Butt
11/18/2013
Thread management done by kernel and
Kernel is aware of threads
Kernel level threads are supported in almost
all modern operating systems:
Windows NT/XP/2000
Linux
Solaris
Tru64 UNIX
Mac OS X
There must be a relationship between user threads
and kernel threads. There exist three common
models of this interaction (1:1, M:1 and M:N)
Implementing Threads in the Kernel
30
CMP320 PUCIT Arif Butt
11/18/2013
Kernel
-
level Threads
•
OS knows about
individual threads within
each process.
•
Thread table maintained
by kernel.
•
E.g.: Windows 2K/XP
Thread Libraries
31
CMP320 PUCIT Arif Butt
11/18/2013
Thread libraries provides programmers with API for
creating and managing threads
Two primary ways of implementing
Library entirely in user space
Kernel
-
level library supported by OS
Pthreads
m
ay be provided either as user
-
level or kernel
-
level.
Pthread
is a POSIX standard (IEEE 1003.1c) API for
thread creation and synchronization
Java Threads
m
anaged by the JVM. Typically
implemented using the threads model provided by
underlying OS. Java threads may be created by: Extending
Thread class, or by implementing the Runnable interface.
If underlying OS is Windows, then implemented using
Win32 API; if it is Linux, then
Pthreads
.
Multi Threading Models
32
CMP320 PUCIT Arif Butt
11/18/2013
Many
-
to
-
One Model
(User Level Threads)
User
–
level
Threads
Kernel
–
level
Thread
Multi Threading Models (…)
33
CMP320 PUCIT Arif Butt
11/18/2013
Many
-
to
-
One Model
(User lvl Threads)
Many user threads per kernel thread; i.e. Kernel
sees just one thread
Advantages
Thread management is done in user space, so it
is efficient.
Disadvantages
When a thread within a process makes a system
call the entire process blocks.
Because only one thread can access kernel at a
time, no parallelism on multiprocessors is
possible.
Example:
POSIX Pthreads, Solaris Green threads, GNU Portable Threads
34
CMP320 PUCIT Arif Butt
11/18/2013
One
-
to
-
One Model
(Kernel lvl threads)
Multi Threading Models (…)
User
–
level
Threads
Kernel
–
level
Threads
P1
P2
35
CMP320 PUCIT Arif Butt
11/18/2013
One
-
to
-
One Model
(Kernel
lvl
threads)
One ULT per KLT, so Kernel sees all threads
Advantage
:
•
When one thread within a process makes a blocking
system call the other threads are not blocked
•
Multiple threads can run in parallel on multi
-
processors
Disadvantage
•
Creating a user thread requires creating the
corresponding kernel thread. There is an overhead
related with creating kernel thread which can be
burden on the performance
Examples
:
Windows NT/XP/2000, Solaris 9 and later, OS/2, FreeBSD
Multi Threading Models (…)
Many
-
to
-
Many M:N Model
(Hybrid Scheme)
36
CMP320 PUCIT Arif Butt
11/18/2013
User
–
level
Threads
Kernel
–
level
Threads
P1
P2
P3
Multi Threading Models (…)
37
CMP320 PUCIT Arif Butt
11/18/2013
Many
-
to
-
Many Model
(Hybrid Scheme)
Multiple user threads are multiplexed over a smaller or equal
number of kernel threads. This model is a compromise
between 1:1 and M:1
User threads in the M:N model normally float among kernel
threads
–
that may run on whatever kernel thread is available
when they become runnable
Advantage
Application can create as many user threads as needed
Kernel threads run in parallel on multiprocessors
If one thread makes a blocking system call, kernel can schedule
another
Examples:
Solaris prior to version 9, HP
-
UNIX, Windows NT/2000 with
the ThreadFiber package
Multi Threading Models (…)
Pop up Threads (Servers)
38
CMP320 PUCIT Arif Butt
11/18/2013
Creation of a new thread when message arrives
(a) before message arrives
(b) after message arrives
User Level
vs
Kernel Level Threads
39
CMP320 PUCIT Arif Butt
11/18/2013
Advantages of ULT
w.r.t
KLT
Thread switching is fast and CPU is not interrupted during
thread switching (No mode switch). Kernel is scheduling the
processes while user level library will be scheduling the thread
Fair Scheduling
(at process level)
: If P1 has one Thread and P2 has
100 threads. Scheduling will be fair for both the processes since
the kernel never know of the user level threads
User level threads can be used even if the underlying
OS/platform doesn't support multithreading
Disadvantages of ULT
w.r.t
KLT
When ever ULT makes a system call, Kernel takes it as the
system call has been made by the process, so all the threads of
the process are blocked.
In a pure ULT strategy, a multithreaded application cannot take
the advantage of multiprocessors.
User Level
vs
Kernel Level Threads
40
CMP320 PUCIT
Arif
Butt
11/18/2013
Advantages of KLT
w.r.t
ULT
When ever a KLT makes a system call, only that thread
is blocked and the Kernel can schedule another thread
of same process. So all the threads of the process are
NOT blocked
In a pure KLT strategy, a multithreaded application
can take the advantage of multiprocessors
Disadvantages of KLT
w.r.t
ULT
Thread switching is slow as CPU is interrupted during
thread switching (Mode switch occurs)
Un Fair Scheduling
(at process level)
: If P1 has one Thread
and P2 has 100 threads. Since the Kernel is aware of
threads, so P2 is going to get more CPU slices
SMT /
Hyperthreading
41
CMP320 PUCIT Arif Butt
11/18/2013
•
There are two forms of multithreading: Temporal
and Simultaneous multithreading (HTT by MS).
•
In
temporal multithreading
, only one thread of
instructions can execute in any given pipeline stage
at a time.
•
In
simultaneous multithreading
, instructions from
more than one thread can be executing in any given
pipeline stage at a time. This is done without great
changes to the basic processor architecture: the
main additions needed are the ability to fetch
instructions from multiple threads in a cycle, and a
larger register file to hold data from multiple
threads (Super scalar Architecture).
•
In short HTT/SMT is multithreading on a superscalar architecture.
SMT /
Hyperthreading
42
CMP320 PUCIT Arif Butt
11/18/2013
Simple superscalar pipeline. By fetching and dispatching two
instructions at a time, a maximum of two instructions per
cycle can be completed.
•
Traditionally, the computer has been
viewed as a sequential machine
–
A processor executes instructions one at a
time in sequence
–
Each instruction is a sequence of operations
•
Two popular approaches to providing
parallelism
–
Symmetric MultiProcessors (SMPs)
–
Clusters
Parallelism (Traditional View)
11/18/2013
43
CMP320 PUCIT Arif Butt
•
Single Instruction Single Data (SISD) stream
–
Single processor executes a single instruction stream to
operate on data stored in a single memory
•
Single Instruction Multiple Data (SIMD) stream
–
Each instruction is executed on a different set of data
by the different processors
•
Multiple Instruction Single Data (MISD) stream
–
A sequence of data is transmitted to a set of
processors, each of execute a different instruction
sequence (Never implemented)
•
Multiple Instruction Multiple Data (MIMD)
–
A set of processors simultaneously execute different
instruction sequences on different data sets
Categories of Computer Systems
11/18/2013
44
CMP320 PUCIT Arif Butt
Parallel Processor Architectures
11/18/2013
45
CMP320 PUCIT Arif Butt
•
In a symmetric multiprocessor (SMP):
•
The kernel can execute on any processor allowing
portions of kernel to execute in parallel
•
Typically each processor does self
-
scheduling from the
pool of available processes or threads.
•
The kernel can be constructed as multiple
processes or multiple threads, allowing portions of
the kernel to execute in parallel. This complicates
the OS.
•
It must ensure that two processors do not choose the
same process and that processes are not somehow lost
from the queue
•
Techniques must be employed to resolve and
synchronize claims to resources
Symmetric Multiprocessing
11/18/2013
46
CMP320 PUCIT Arif Butt
Typical SMP Organization
11/18/2013
47
CMP320 PUCIT Arif Butt
48
CMP320 PUCIT Arif Butt
11/18/2013
11/18/2013
49
CMP320 PUCIT Arif Butt
Call
Description
pthread_create
()
Similar to fork()
pthead_join
()
Similar
to
waitpid
()
pthread_self
()
Similar to
getpid
()
pthread_detach
()
To detach a thread
pthread_exit
(void *status)
To terminate a thread
pthread_equal
()
To compare
two threads
Thread Management
Important POSIX System Calls
•
Thread operations include thread creation, termination, synchronization (joins,
blocking), scheduling, data management and process interaction.
•
A thread does not maintain a list of created threads, nor does it know the
thread that created it.
System Call
–
pthread_create()
int
pthread_create
(
pthread_t
*
threadp
,
const
pthread_attr_t
*
attr
,
void * (*routine)(void *),
void*
arg
);
•
threadp
is the thread we are trying to create.
•
attr
is used to modify the thread attributes(e.g.
stack size, stack address, detached, joinable, priority
…). A NULL means default attributes.
•
routine
is the thread function.
•
*
arg
is a pointer to argument of function. To pass
multiple arguments send a pointer to a structure.
11/18/2013
50
CMP320 PUCIT Arif Butt
System Call
–
pthread_create()
Error Handling:
•
If any of the following conditions are detected,
pthread_create
() fails and returns the
corresponding value:
–
EAGAIN
. The system imposed limit on the total number of
threads in a process has been exceeded or some system resource
has been exceeded.
–
EINVAL.
The value specified by
attr
is invalid.
–
ENOMEM.
Not enough memory was available to create the new
thread..
•
Error Handling:
–
#include <
errno.h
>
–
Error Handling code.
11/18/2013
51
CMP320 PUCIT Arif Butt
System Call
–
pthread_exit()
int
pthread_exit
(void *
valuep
);
•
valuep
is the thread for which we want to wait. We
will use NULL.
11/18/2013
52
CMP320 PUCIT Arif Butt
•
There are three reasons of thread termination:
•
Main thread terminates, all threads must terminate.
•
A thread uses return call.
•
A thread explicitly uses pthread_exit() system call.
System Call
–
pthread_join()
Suspend
the
execution
of
calling
thread
until
the
target
threads
terminates
.
int
pthread_join
(
pthread_t
aTthread
,
void **
statusp
);
•
aThread
is the thread for which we want to wait.
•
statusp
will contain the return value of
pthread_exits
, we will use NULL here
11/18/2013
53
CMP320 PUCIT Arif Butt
Example 1
11/18/2013
54
CMP320 PUCIT Arif Butt
/*
t1.c
(Main function creates a thread and then wait, the
thread executes the
MyThreadFunc
and returns to main*/
#include <
stdio.h
>
#include <
stdlib.h
>
#include <
pthread.h
>
void *
MyThreadFunc
(void *
arg
);
int
main(){
pthread_t
aThread
;
pthread_create
(&
aThread
, NULL,
MyThreadFunc
, NULL);
pthread_join
(
aThread
, NULL);
printf
(“Exiting the main function.
\
n");
return 0;
}
v
oid
*
MyThreadFunc
(void *
arg
){
printf
(“Hello World!... The threaded version
\
n");
return NULL;
}
Running the Code
11/18/2013
55
CMP320 PUCIT Arif Butt
Use any editor to type your program and then to compile use gcc compiler:
$ gcc t1.c
–
o t1
–
lpthread
[
-
D_REENTRANT]
$ ./t1s
Hello world!... The threaded version
Exiting main function.
$
Example 2
56
/*
t2.c
(Main function creates a thread, pass it a
msg
and then
wait, the thread executes the
MyThreadFunc
, displays the
message and returns to main*/
#include <
stdio.h
>
#include <
stdlib.h
>
#include <
pthread.h
>
void *
MyThreadFunc
(void *
arg
);
int
main(){
char *
msg
= “Hello World!... The threaded version”;
pthread_t
aThread
;
pthread_create
(&
aThread,NULL,MyThreadFunc
,
(void*)
msg
);
pthread_join
(
aThread
, NULL);
printf
(“Exiting the main function.
\
n");
return 0;
}
v
oid
*
MyThreadFunc
(void *
arg
){
char* message = (char*)
arg
;
printf
(“%s
\
n”, message);
return NULL; }
11/18/2013
CMP320 PUCIT Arif Butt
Example 3
11/18/2013
57
CMP320 PUCIT Arif Butt
/*
t3.c
(Main function creates a thread, pass it an integer
value and then wait, the thread executes the
MyThreadFunc
which
sleeps for the time passed to it by main and then returns to
main*/
void *
MyThreadFunc
(void *
arg
);
int
main(){
int
sleepTime
= 5;
pthread_t
aThread
;
pthread_create
(&
aThread,NULL,MyThreadFunc
,(void*)
sleepTime
);
sleep(2);
printf
(“This is main thread executing….
\
n”);
pthread_join
(
aThread
, NULL);
printf
(“Exiting the main function.
\
n");
return 0;
}
Example 3 (cont…)
11/18/2013
58
CMP320 PUCIT Arif Butt
void * MyThreadFunc(void * arg){
int sTime = (int) arg;
printf(“I will sleep for %i seconds
\
n”, sTime);
printf(“Sleeping... Zeeeeeeeeeeeeeeeeee
\
n");
sleep(sTime);
printf(“I am awake now Good Bye !
\
n”);
return NULL;
}
Example 4
11/18/2013
59
CMP320 PUCIT Arif Butt
/*
t4.c
(Main function creates two threads t1 and t2, pass them
an integer constant 5 and then wait, the two threads executes
the MyThreadFunc, which prints from 1 to 5 and returns to
main*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define COUNT 5
void * MyThreadFunc(void * arg);
int main(){
pthread_t t1, t2;
pthread_create(&t1 ,MyThreadFunc, (void*) COUNT);
pthread_create(&t1 ,MyThreadFunc, (void*) COUNT);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
printf(“Exiting the main function.
\
n");
return 0;}
Example 4 (cont…)
11/18/2013
60
CMP320 PUCIT Arif Butt
void * MyThreadFunc(void * arg){
int num = (int) arg;
int i;
for(i=1; i<=num; i++){
printf(“%i
\
n”,i)
//sleep(1);
}
pthread_exit(NULL);
}
SUMMARY
61
CMP320 PUCIT Arif Butt
11/18/2013
We’re done for now, but
Todo’s for you after this
lecture…
62
CMP320 PUCIT Arif Butt
If you have problems visit me in counseling hours. . . .
•
Go through the slides and Book Sections:
4.1, 4.2, 4.3, 4.4
•
Write down the programs discussed in class in vim editor and execute
them. Make variations in the programs and understand the underlying
details
•
Write down a C program having an integer variable counter initialized to
zero. Now create two threads, one thread increments the variable counter
100,000 times and the other thread decrements the same counter variable
100,000 times. Once both threads terminates the main thread prints the
final value of the counter variable. See results and discuss in next class
•
Understand the difference between fork() and clone() system call
•
Study books and understand the concept of
•
Thread Pool
•
Thread Cancellation
•
Signal handling in multithreaded programs
11/18/2013
Enter the password to open this PDF file:
File name:
-
File size:
-
Title:
-
Author:
-
Subject:
-
Keywords:
-
Creation Date:
-
Modification Date:
-
Creator:
-
PDF Producer:
-
PDF Version:
-
Page Count:
-
Preparing document for printing…
0%
Comments 0
Log in to post a comment