1

CMSC421: Principles of Operating Systems

Nilanjan Banerjee

Principles of Operating SystemsAcknowledgments: Some of the slides are adapted from Prof. Mark Corner

and Prof. Emery Berger’s OS course at Umass Amherst

Assistant Professor, University of MarylandBaltimore Countynilanb@umbc.edu

http://www.csee.umbc.edu/~nilanb/teaching/421/

2

Announcements

• Readings from Silberchatz [4th and 6th chapter]

3

Scheduling

One-one (linux)Many-one (Green Threads)

Many-many (Window-NT)

4

How does it work in Linux

Linux refers to them as tasks rather than threads

Thread creation is done through clone() system call

clone() allows a child task to share the address space of the parent task (process)

struct task_struct points to process data structures (shared or unique)

5

When to use Threads and When to use processes

Processes or Threads Performance? Flexibility/Ease-of-use Robustness

Simple Scheduling OS has a list of Threads and schedules them

similar to Processes. In Linux, threads/processes treated similarly

Chooses one of the threads and loads them to be run

Runs them for a while, runs another.

6

Flexibility/Ease of use?

Process are more flexible Easy to spawn processes, I can ssh into a server and

spawn a process Can communicate over sockets= distributes across

machines

Threads Communicate using memory – must be on the same

machine Requires thread-safe code

7

Robustness

Process are more robust Processes are separate or sandboxed from other

processes If one process dies, no effect on other processes

Threads If one thread crashes, whole process terminates Since there is sharing, there are problems with using the

stack efficiently

8

Context Switch cost

Threads – much cheaper– Stash registers, PC (“IP”), stack pointer

Processes – above plus– Process context – TLB shootdown (later in VM lecture)

Process switches more expensive, or require long quanta

9

Synchronization and Concurrency

Probably the MOST important concept in OS

Lets look at a demonstration

10

What really happened?

load X R1

add Y Z R1

store Y in Mem

Thread 1 executes the first two statementsand is preempted…

Thread 2 executes all the three statements

Thread 1 returns and executes the third statement

Count = count + 1

11

Concurrency Terminology

Mutual exclusion (“mutex”)– prevents multiple threads from entering

Critical section– code only one thread can execute at a

time Lock

– mechanism for mutual exclusion– Lock entering critical section, accessing

shared data– Unlock when complete– Wait if locked

Invariant– Something that must be true

12

Why do we need concurrency?

Synchronization serves two purposes:– Ensure safety for shared updates

• Avoid race conditions– Coordinate actions of threads

• Parallel computation• Event notification

ALL interleavings must be correct– there are lots of interleavings of events– also constrain as little as possible

13

Locks/mutexes

Provide mutual exclusion to shared data– Two routines

• acquire – wait for lock, then take it• release – unlock, wake up waiters

Rules:– Acquire lock before accessing shared data– Release lock afterwards– Lock initially released

14

Locks and Queueing

• Acquire:– if unlocked,

go in;otherwise wait in line

• Release:– Unlock & leave

15

Synchronization and Concurrency

Demonstration on using pthread locks/mutexes

16

Implementing Locks

Requires hardware support (in general) Can build on atomic operations:

– Load/Store– Disable interrupts

• Uniprocessors only– Test & Set, Compare & Swap

17

Disabling Interrupts

int value; Queue q;

FREE = 0, BUSY = 1 value = 0; q = empty;

void acquire () { disable interrupts; if (value == BUSY) { add this thread to q;

enable interrupts; sleep(); } else { value = BUSY; } enable interrupts; }

void release () { disable interrupts; if (q not empty) { thread t = q.pop(); put t on ready queue; } value = FREE;

enable interrupts; }

18

Lock Variants

Implementing Locks with Test and Set Blocking Locks Spin locks Hybrids

19

Atomic Operation

But: locks are also variables, updated concurrently by multiple threads– Who locks the lock?

Answer: use hardware-level atomic operations– Test-and-set– Compare-and-swap

20

Test and Set semantics

What’s the effect of testAndset(value) when: value = 0? (“unlocked”) value = 1? (“locked”)

int testAndset (int* v) { int old = *v; *v = 1; return old;}

21

Blocking Locks

Suspend thread immediately– Lets scheduler execute another thread– Go to back of run queue or wait to be woken

Minimizes time spent waiting But: always causes context switch

void blockinglock (Lock& l) { while (testAndSet(l.v) == 1) { sched_yield(); }}

22

Spin Locks

Instead of blocking, loop until released

void spinlock (Lock& l) { while (testAndSet(l.v) == 1) { ; }}

23

Other variants

Spin-then-yield:– Spin for some time, then yield

• Fixed spin time• Exponential backoff

24

Safety

Locks can enforce mutual exclusion,but notorious source of errors– Failure to unlock– Double locking– Deadlock (its own lecture)– Priority inversion

• not an “error” per se pthread_mutex_t l;void square (void) { pthread_mutex_lock (&l); // acquires lock // do stuff if (x == 0) { return; } else { x = x * x; } pthread_mutex_unlock (&l);}

25

An in-class discussion