1 threads & scheduling what are threads? vs. processes where does os implement threads?...

1

Threads & Scheduling

What are threads? vs. processes

Where does OS implement threads? User-level, kernel

How does OS schedule threads?

2

Processes versus Threads

Process = Control + address space + resources fork()

Thread = Control only

PC, stack, registers pthread_create()

One process may contain many threads

3

Threads Diagram

Threads in a process Each has a thread ID,

PC, registers, stack share: Address space in

process (e.g., code section, data, resources)

Advantages: Less overhead in

creating and destroying threads

Cheaper, faster communication than IPC

4

Threads Example, C/C++, POSIX#include <pthread.h>

#include <stdio.h>

void* start(void* arg)

{

int tmp, thread_index = (int)arg;

tmp = 200 * (int)arg;

arg = (void *) tmp;

printf("Thread %d about to terminate\n",thread_index);

return arg;

}

int main() {

pthread_t thr;

int i = 1,st;

void* rv;

st = pthread_create(&thr,NULL,start,(void*)i);

if (st!=0) printf("pthread_create failed with status: %d\n",st);

pthread_join(thr,&rv);

printf("thread %d returned %d\n",i,rv);

return 0;

}

5

POSIX Thread Example, II

Compile: gcc –g –o test test.c –lpthread

pthread_create pthread_join

Principal thread blocks until the specified child terminates

Second argument stores the return value

6

Classifying Threaded Systems

One or many address spaces, one or many threads per address space

MS-DOS

7

Classifying Threaded Systems

One or many address spaces, one or many threads per address space

MS-DOS

Embedded systems

8

Classifying Threaded Systems

One or many address spaces, one or many threads per address space

UNIX, Ultrix,MacOS (< X),

Win95

Embedded systems

MS-DOS

9

Classifying Threaded Systems

One or many processes, one or many threads per process

UNIX, Ultrix,MacOS (< X),

Win95

Mach,Linux,Solaris,WinNT

MS-DOS

Embedded systems

10

Threads

What are threads? vs. processes

Where does OS implement threads? Kernel, user-level

How does CPU schedule threads?

11

Kernel Threads

Kernel threads: scheduled by OS Switching threads requires context

switch PC, registers, stack pointers BUT: when in same process, no mem mgmt. =

no TLB “shootdown” Examples: Windows 95 & up

Switching faster than for processes

Can be scheduled on multiple processors

12

User-Level Threads

No OS involvement w/user-level threads Only knows about process containing

threads Use thread library to manage threads

Creation, synchronization, scheduling Example: Green threads (Solaris)

Cannot be scheduled on multiple processors

13

User-Level Threads: Advantages

Flexible: Can define problem-specific thread scheduling

policy Computations first, service I/O second, etc.

Each process can use different scheduling algorithm

Can be much faster than kernel threads Context might be very small No system calls for creation, switching threads,

synchronization (not cross user-kernel boundary)

14

User-Level Threads: Disadvantages

Requires cooperative threads Must yield when done working (no quanta) Uncooperative thread can take over

OS knows about processes, not threads: Thread blocks on I/O: whole process stops More threads ≠ more CPU time

Process gets same time as always Can’t take advantage of multiple

processors

15

Hybrid Model

User-level threads mapped onto light-weight process (LWPs)

16

Hybrid Model: Advantages

“Best of both worlds” Multiplex multiple user-level

threads to a smaller or equal number of kernel threads (take advantage of multiple processors)

May not be a one-to-one mapping (flexible, faster)

17

Hybrid Model: Load Balancing

Spread user-level threads across LWPs so each processor does same amount of work Solaris scheduler: only adjusts load when I/O blocks

threadscheduler

kernel

threadscheduler

threads

processes

processors

18

Threads Roundup

User-level threads Cheap, simple Not scheduled directly, blocks on I/O, single CPU Requires cooperative threads

Kernel-level threads Involves OS – time-slicing (quanta) More expensive context switch, synch Doesn’t block on I/O, can use multiple CPUs

Hybrid “Best of both worlds”, but requires load

balancing

19

Threads & Scheduling

What are threads? vs. processes

Where does OS implement threads? User-level, kernel

How does OS schedule threads?

20

Scheduling

Overview Metrics Long-term vs. short-term Interactive vs. servers Example algorithm: FCFS

21

Scheduling

Multiprocessing: run multiple processes Improves system utilization &

throughput Overlaps I/O and CPU activities

22

Scheduling Processes

Long-term scheduling: How does OS determine

degree of multiprogramming? Number of jobs executing at once

Short-term scheduling: How does OS select program from

ready queue to execute? Policy goals Implementation considerations

23

Long-term Scheduling

Goal: select a good mix of I/O-bound and

CPU-bound processes I/O-bound process: spending more

of its time on doing I/O than computation

CPU-bound process: using more of its time on computation, e.g., displaying video

24

Short-Term Scheduling

Kernel may run scheduler when:1. process switches from running to waiting2. process switches from running to ready

(e.g. interrupt)3. process switches from waiting to ready4. processes terminated

Non-preemptive system: Schedule only under 1 & 4

Preemptive system: Schedule under any in 1-4

25

Comparing Scheduling Algorithms

Important metrics: Utilization = % of time that CPU is

busy Throughput = processes completing /

time Response time

= time between submission to first response

Waiting time = time process spends on ready queue

26

Scheduling Issues Ideally:

Maximize CPU utilization, throughput &minimize waiting time, response time

Conflicting goals Cannot optimize all criteria

simultaneously

Must choose according to system type Interactive systems Servers

27

Scheduling: Interactive Systems

Goals for interactive systems: Minimize average response time

Time between submission to first response Provide output to user as quickly as

possible Process input as soon as received

Minimize variance of response time Predictability often important Higher average better than low average,

high variance

28

Scheduling: Servers

Goals different than for interactive systems

Maximize throughput (jobs done / time) Minimize OS overhead, context switching Make efficient use of CPU, I/O devices

Minimize waiting time Give each process same time on CPU May increase average response time

29

Scheduling Algorithms Roundup

FCFS: First-Come, First-Served

Round-robin: Use quantum & preemption to

alternate jobs SJF:

Shortest job first Multilevel Feedback Queues:

Round robin on each priority queue

30

Scheduling Policies

FCFS (a.k.a., FIFO = First-In, First-Out)

Scheduler executes jobs to completionin arrival order

Early version: jobs did not relinquish CPU even for I/O

31

FCFS Scheduling: Example

Question: average wait time for these three examples?

Assumptions:(1) Single CPU(2) Non-preemptive(3) Ignore context-switch

time(4) Length of the jobs: A:5,

B:2, C:3

Ex1: Arrival time: B:0, C:1, A:2, no I/O

Ex2: Arrival time: A:0, B:1, C:2, no I/O

Ex3: Arrival time: A:0, B:1, C:2, A does I/O after 2 time units and I/O takes 2 time units

32

FCFS:Advantages & Disadvantages

+ Advantage: Simple- Disadvantages:

- Average wait time highly variable Short jobs may wait behind long jobs

- May lead to poor overlap of I/O & CPU CPU-bound processes force I/O-bound

processesto wait for CPU

I/O devices remain idle

33

Summary

Thread = single execution stream within process User-level, kernel-level, hybrid

No perfect scheduling algorithm Selection = policy decision Base on processes being run &

goals Minimize response time Maximize throughput etc.