Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 13 Annotated
13 - Threads (2)
Outline
Thread Implementation
Thread Switching
Multithreaded Code
Rule of Thumb
Windows Threads
Announcements
Reading: MOS 2.2.1 - 2.2.6
Thread Implementation
User-space
Per-thread
Kernel-space
Per-process
Hybrid implementation
Thread Switching
Multithreaded Code
3 approaches to implementing threads:
Threads originally implemented as a user-space
library.
User-space Threads
Do user-space threads keep one stack per thread
or one stack per process?
In kernel mode, replace the process structs with
thread structs.
In user mode, switching is handled with yield calls
from the threads themselves.
Thread library maintains scheduler loop that saves
and restore thread context on the yields.
Programs were originally designed for a single CPU,
single-threaded.
Some differences from process switching:
PollEv
Kernel-space Threads
Hybrid Implementation
No prepared statements.
1)
1)
A)
2)
2)
B)
3)
3)
-
-
-
-
-
-
-
-
-
Avoid global variables
Library procedures may not support multithreading!
Note: printf and errno have long been fixed.
Identical output to our pthreads demo.
If you have Windows you can try it.
Alternatives:
Warning
-
-
-
-
-
-
-
-
-
-
Kernel doesn't see threads, only schedules
processes.
switching threads within a process is faster
Many libraries not originally designed for
multithreaded execution.
e.g. printf was designed with an internal buffer
considered poor practice in large codebases
Functions must be reentrant / thread-safe to
be used in multithreaded context
It is the programmer's responsibility to know if
the functions used are thread-safe.
Private globals in
Thread-local storage
shared by default and require synchronization
Getters and setters that wrap synchronization
e.g. errno was a shared global
buffer was written to stdout only on certain conditions (full
or newline-terminated)
used with perror to print detailed error messages
implemented with compiler
support:
syscalls in different threads could overwrite errno
errno is a macro now.
buffer was shared among threads, which would overwrite one
another without synchronization
switching threads in different processes is slow
no need to change address space => no cache invalidation
swapping address space results in cache invalidation, which
requires write-back to main memory
Thread library maintains its own thread table
and scheduling/switching algorithm.
Kernel can manage scheduling more efficiently
user thread libraries exist on top of kernel-
provided thread API
can have multiple user threads per kernel thread
user-threads typically mapped one-to-one to
kernel threads
multiplexing threads is complex, more uncommon.
user-space library (e.g. pthreads API) wraps the kernel API
Kernel maintains
process table +
thread table
Kernel schedules
threads instead
of processes
The disadvantages of user-space threads are
significant.
Close modern example: async-await libraries.
Thread table
lives in process
memory
Thread library
implements a
thread runtime
for switching
Advantages:
Advantages:
Disadvantages:
Disadvantages:
-
-
-
-
-
-
-
no need for kernel support
=> easier implementation
=> no syscalls required
==> no switching overhead
==> faster thread creation
kernel-managed scheduling
=> fair CPU time distribution
=> no per-process thread lib
no thread library loading
no thread table in memory
kernel can't see threads
=> thread CPU time less fair
requires thread syscalls
=> more time in kernel
scheduling managed manually
with yield calls
kernel trapping must be offset
by gains from parallelism
kernel required for use of
multicore parallelism
signal behavior for
multithreaded processes
=> kill all the threads?
=> which thread handles?
syscalls and page faults block
all threads
fork behavior for
multithreaded processes
=> which threads to copy?
Processes can use different
thread libraries
I/O syscalls don't block other
threads
Libraries can use different
scheduling algorithms
multi-core parallelism
-
-
-
Portability
Scheduling
Scheduling Complexity
Syscall Overhead
Blocking Operations
Open Problems
No Parallelism
Flexibility
Parallelism
Memory Efficiency
Thread implementation moved into the kernel.
Modern implementations have hybrid approach.
save state to PCB 0
save state to PCB 1
load state from PCB 1
load state from PCB 0
P0
Thread 0
Thread 1
Kernel
P1
handle interrupt/
do syscall;
scheduler runs
handle interrupt/
do syscall;
scheduler runs
interrupt
or syscall
interrupt
or syscall
running
running
running
ready
ready
ready or blocked
ready or blocked
TCB 0
TCB 1
TCB 1
TCB 0
GCC
C11 Standard
__thread int i;
extern __thread struct state s;
static __thread char *p;
#include <threads.h>
thread_local int foo = 0;
create_global("bufptr");
set_global("bufptr", &buf);
bufptr = read_global("bufptr");
or yield
or yield