1

OS

2Operating System

Just a program Provides a stable, consistent way for

applications to deal with the hardware

3What constitutes an OS?

Kernel

System Programs

Application Programs

5Storage Device Hierarchy

6Cache

Writing policies

Write back Initially, writing is done only to the cache Mark them as dirty for later writing to the

backing store

Write through Write is done synchronously both to the

cache and to the backing store

Replacement Policy?

7System Calls

Instructions that allow access to privileged or sensitive resources on the CPU

System calls provide a level of portability

Parameters to system calls can be passed through registers, tables or stack

Is “printf” a system call?

8System Calls

File copy program Acquire input file name Acquire output file name If file cannot be created abort Open input file If file doesn't exist abort Read from input file Write to output file Repeat until read fails Close output file Terminate normally by returning closing status to

OS

9Operating System Operation

Interrupt driven Dual Mode Operation

“Kernel” mode (or “supervisor” or “protected”) “User” mode: Normal programs executed

10

Operating System Operation

Timer

Interrupts the computer after a specified period

May be treated as a fatal error or may give the program more time Penny, Penny, Penny

11

Process

A program in execution A single ‘thread’ of execution

Uniprogramming: one thread at a time

Multiprogramming: more than one thread at a time

12

Process States

New : Process is being created Ready : Process waiting to run Running : Instructions are being executed Waiting : Process waiting for some event to occur Terminated : The process has finished execution

13

Process Control Block(PCB)

ProcessControlBlock

Only one PCB active at a time

14

Process Creation

vi catemacs

ls

init

CSH CSH

pid=1

Pid=7778

Pid=1400

Parent followed by a child process

15

Process Creation – Fork()

16

A Question (Microsoft)

17

Inter Process Communication

Shared-Memory Systems A process creates a shared-memory segment Other processes attach it to their address space

Message-Passing Systems send(P, message) receive(id, message)

18

IPC - Pipes

Pipes are OS level communication links between processes

Pipes are treated as file descriptors in most OS

19

Multithreading

Each thread has its own stack – current execution state Threads encapsulate concurrency

20

Multithreading

Advantages Responsiveness Resource Sharing Economy Scalability

Pthreads POSIX standard defining an API for thread creation

and synchronization

21

A Question (Google)

22

Scheduling

Scheduling – Deciding which threads are given access to resources from moment to moment

The CPU should not be idle

At least on process should use CPU

23

Scheduling

Scheduling – Deciding which threads are given access to resources from moment to moment

24

Scheduling

Goals/Criteria Minimize Response Time Maximize Throughput Fairness

First-Come, First-Served (FCFS) Scheduling Run until done Shorts jobs get behind long ones

P1 P2 P3

24 27 300

25

Preemption

Capability to preempt a process in execution

Execution prioritized

Higher priority processes preempt the lower ones

26

Round Robin (RR)

Each process gets a small unit of CPU time(time quantum) After quantum expires, process is preempted and added to the

end of ready queue N processes in ready queue and time quantum is q

No process waits more than (N-1)q time units

Performance q large -> FCFS q must be large with respect to context switch,

otherwise too much overhead

27

Round Robin (RR)

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 28 48 68 88 108 112 125 145 153

Process Burst Time

P1 53

P2 8

P3 68

P4 24

Waiting time for P1 = ?, P2 = ?, P3 = ?, P4 = ?

Average Waiting Time = ?Average Completion Time = ?

28

Round Robin (RR)

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 28 48 68 88 108 112 125 145 153

Process Burst Time

P1 53

P2 8

P3 68

P4 24

Waiting time for P1 = (68-20) + (112-88) = 72, P2 = 20, P3 = 85, P4

= 88

Average Waiting Time = 66.5Average Completion Time = 104.5

29

Round Robin (RR)

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 28 48 68 88 108 112 125 145 153

Process Burst Time

P1 53

P2 8

P3 68

P4 24

Pros and Cons: Better for short jobs Context-switching adds up for long jobs

30

What if we know future?

Shortest Job First (SJF) Run whatever job has the least amount of

computation to do

Shortest Remaining Time First (SRTF) Preemptive version of SJF: if job arrives

and has a shorter time to completion than the remaining time on the current job, immediately preempt CPU

Basically Idea is to get short jobs out of the system Big effect on short jobs, only small effect on long ones Result is better average response time

31

Synchronization

Most of the time, threads are working on separate data, so scheduling doesn’t matter

But, what happens when they work on a shared variable

Atomic Operations An operation that always runs to completion or not at all Indivisible Fundamental Building Block

32

Synchronization

Synchronization Using atomic operations to ensure cooperation between

threads

Mutual Exclusion Only one thread does a particular thing at a time

Critical Section Piece of code that only one thread can execute at once

Lock Prevents someone from doing something

33

Synchronization

Load/Store Disable I nts Test&Set Comp&Swap

Locks Semaphores Monitors Send/Receive

Shared Programs

Hardware

Higher-level API

Programs

Everything is pretty painful if only atomic primitives are load and store

34

Semaphores

A kind of generalized lock

Definition: A semaphore has a non-negative integer value and supports the following two operations

P() : An atomic operation that waits for semaphore to become positive, then decrements it by 1 Also called the wait() operation

V() : An atomic operation that increments the semaphore by 1, waking up a waiting P, if any Also called the signal() operation

35

Semaphores Implementation

36

Semaphore vs Mutex

Nope, the purpose of mutex and semaphore are different

Mutex is locking mechanism used to synchronize access to resource. Ownership associated with mutex. Only the owner can release the lock.

Semaphore is Signaling mechanism (“I am done, you can carry on” kind of signal)

More at http://www.geeksforgeeks.org/mutex-vs-semaphore/

Are binary semaphore and mutex same?

37

Readers-Writers

Problem : Several readers and writers accessing the same file Need to control access to buffer If several readers are reading, no problem If writer is writing and reader is reading, some problem

Variations First-Writers-Then-Readers First-Readers-Then-Writers

38

Readers-Writers

39

Deadlocks

P0

Wait(Q)Wait(S)

Some code here

Signal(Q)Signal(S)

P1

Wait(S)Wait(Q)

Some code here

Signal(S)Signal(Q)

A deadlock is a situation in which two or more competing actions are each waiting for the other to finish, and thus neither ever does.

40

Deadlock Requirements

Mutual Exclusion Only one thread at a time can use a resource

Hold and Wait Thread holding at least one resource is waiting to acquire

additional resources held by other threads

No preemption Resources are released only voluntarily by the thread holding

the resource, after thread is finished with it

Circular Wait There exists a set {T1, …, Tn} of waiting threads

T1 is waiting for a resource that is held by T2

T2 is waiting for a resource that is held by T3

… Tn is waiting for a resource that is held by T1

41

Some Techniques

Deadlock Detection Resource allocation graph etc.

Prevention Circular Wait

Avoidance Banker’s algorithm