Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 12 Template
12 - Threads (1)
Outline
Thread Basics
POSIX Threads
Announcements
Reading: MOS 2.2.1 - 2.2.6
Thread Basics
POSIX Threads
Thread Data Structures
Process creation is inefficient
Problems with Processes
Threads vs. Processes
Advantages and Disadvantages
Example: Web Server
Efficiency: Amdahl's Law
Complexity: Shared Variables
Thread Dynamics
Processes (usually) don't share memory directly
A thread is an independently executed sequence of
executed instructions within a process.
A thread cannot exist without a process.
Unlike processes, threads share non-execution-
related resources.
Applications can have multiple processes with
multiple threads.
Certain items must now be stored per-process and
per-thread:
How are the separate stacks managed in process
address space?
> Each process starts with a single "main" thread
> Threads can create new threads
> Threads can end at any point
> Threads can wait for other threads
> Threads can yield execution to other threads
Simple web server has 2 jobs:
Facilitating connection is an I/O-bound task, while
performing work is (should be) a CPU-bound task.
Doing both in a single thread would cause long
response times, since many requests come in.
I/O wait would cause work to be delayed.
Multi-core multithreading can give performance
improvements, but improvement is not linear.
Amdahl's law gives an upper bound on program
speedup as a function of the fraction of the
program's serial work and the number of cores.
Derivation:
Multithreading requires some initialization and
synchronization that must be done serially.
Accesses need to be coordinated somehow
only defines API, not implementation
kernel keeps PCBs in a process table
separates program execution data from PCB:
PCB contains:
TCB contains program execution data
PCB contains everything else
Synchronization algorithm required
PA 2 autograder is uploaded. It may be updated
one more time, but we will re-run it on our end if
needed.
1)
2)
3)
-
-
-
-
-
-
-
-
Must create and copy data to a large PCB
executing the main() function
there can be parent/child relationships
if main thread returns, exit syscall will
terminate process, killing all threads.
Significant overhead
Separate address spaces and resources so
users can't interfere with one another.
Inter-process communication (IPC) has
overhead due to syscalls
Process is needed to provide address space
and other resources to one or more threads.
Multiprocessing
(single thread)
Multithreading
(single process)
code
code
regs
regs
regs
regs
PC
PC
PC
stack
stack
stack
PC
stack
data
data
heap
heap
single-threaded
process
multithreaded
process
Per-Process:
Advantages:
- Address space
- Global variables
- Open files
- Child processes
- Pending alarms
- Signals & handlers
- Accounting
- Program counter
- Registers
- Stack
- Status/state
Per-Thread:
Disadvantages:
e.g. ready, running, blocked
see MOS Figure 2-12
kernel space
thread 0 stack
thread 1 stack
thread 2 stack
heap
bss
data
text
ffffffff_ffffffff
00000000_00000000
Address
Space
thread 0 SP
thread 1 PC
thread 0 PC
thread 2 PC
thread 1 SP
thread 2 SP
shared
-
-
-
shared address space
=> no syscalls required
==> no comms overhead
=> no copying required
==> fast thread creation
bugs can crash other threads,
or the entire process
accessing shared data
simultaneously requires
synchronization
Programs can perform I/O and
compute tasks concurrently
Programs can take advantage
of multi-core parallelism
-
-
-
-
-
-
-
-
-
- Process state/status
- PID
- PC
- Registers
- Scheduling info
- Memory management info
- Allocated resources
- etc.
e.g. program counter, registers, scheduling info, pending I/O
e.g. memory management info, accounting info
-
Performance
No Isolation
Complexity
Efficiency
- Manage client connections
- Perform work for the client
I/O-bound
Dispatcher thread
Worker thread
most time is spent waiting on I/O
most time is spent on CPU compute
CPU-bound
S
S
T
P
N
serial portion of program as fraction
serial portion
single core runtime in unit time
On a single core:
Single-core Runtime:
N-core Runtime:
Speedup:
Example:
An application is 75% parallel and 25% serial.
Moving from 1 to 2 cores gives the following upper
bound on speedup:
For N -> infinity:
Serial portion of an application has a
disproportionate effect on performance gain from
multicore parallelism.
Multiple threads may access the same global
variable concurrently.
parallel portion
number of cores
thread 0
modify(&val)
modify(&val)
0x1000 : 0x12345678 (val)
0x1004 : ...
0x1008 : ...
modify(&val)
thread 1
thread 2
global
memory
Example:
Code would be correct when executed serially, but
interleaving causes issues:
POSIX defines an API for threads:
Recall Process Control Block
Threads have an analog: Thread Control Block
1: void push_back(LIST * list, int v)
2: {
3: NODE * n = malloc(sizeof(NODE));
4: n->value = v;
5: n->next = NULL;
6: list->tail->next = n;
7: list->tail = n;
8: }
thread A:
run 3,4,5
thread B:
run 3,4,5,6
thread A:
run 6,7
thread B:
run 7
list
head
tail
created by thread A
created by thread B
pthreads
Function
pthread_create
create a new thread
terminate the calling thread
wait for specific thread to exit
release CPU to another thread
create and init thread attribute struct
remove thread attribute struct
note: pthread_yield is deprecated in favor of sched_yield
Windows has a different thread API
pthread_exit
pthread_join
sched_yield
pthread_attr_init
pthread_attr_destroy
Description
A subset of the API:
Example:
see MOS Figure 2-14
Thread Data Structures
stack
heap
bss
data
text
PCB
...
...
...
...
pid
TID: 2
TID: 1
TID: 0
PC
SP
SP
SP
SP
PC
PC
PC
PCB
PCB
PCB
thread 0 stack
thread 1 stack
thread 2 stack
heap
bss
data
text
thread table
PCB
...
PID
UID
GID
Address Space
Separating out the execution state from memory
allows concurrent execution of:
different parts of the program code
same parts of program code with different data
-
-