Operating Systems Principles Process Management and Coordination Lecture 4: The Operating System...

Operating Systems PrinciplesProcess Management and Coordination

Lecture 4:The Operating System Kernel:

Implementing Processes and Threads

主講人：虞台文

Content Kernel Definitions and Objects Queue Structures Threads Implementing Processes and Threads

– Process and Thread Descriptors– Implementing the Operations

Implementing Sync/Comm Mechanisms– Semaphores and Locks– Building Monitor Primitives– Clock and Time Management– Communications Kernel

Interrupt Handling

Kernel Definitions and Objects

Windows Kernel

Hardware dependent functions are placed in the kernel.

OS Kernel

A basic set of objects, primitives, data structures, processes from which the remainder of the system may be built on its top.

In other words, the kernel transforms the hardware into an OS’s machine.

OS’s Machine

I am staying on the top of an OS

machine.

Kernel Objects

Kernel defines/provides mechanisms to implement various policies.

Four classes of possible functions and objects in a kernel: – Process and thread management– Interrupt and trap handling– Resource management– Input/output

Kernel ObjectsProcess and thread managementInterrupt and trap handlingResource managementInput/output

Process and thread management

– Process Creation

– Process Destruction

– Process Communication/Synchronization

Interrupt and trap handling– Responding to signals triggered by various

system events. Some system events:

– Process termination– I/O completion– Time-out of clock– Error– Hardware malfunction

......

Interrupt and trap handling– Responding to signals triggered by various

system events.

CPUCPU I/OProcessor

I/OProcessor

Start I/O

Interrupt

......Do_I/O......

InterruptServiceRoutine

Resource management– Primitives for maintaining, allocating, and

releasing system resources. Some system resources:

– CPUs– Timers– Main memory– Secondary storage– I/O devices– Files

Input/output– Read, write, and control operations for

initiating and supervising the transfer of data between I/O devices and main memory or registers.

Main Topics in the Lecture

Process and thread management

Interrupt and trap handling

Resource management

Input/output

Main topics

Process Creation Hierarchy

KernelKernel

p1p1 pn

q1q1 qm

. . . . . .

OS process

user 1 login

user j login user n login user

processes

applicationprocesses.

childprocesses

el obje

Queue Structures

Queues

OS needs many different queues– e.g., ready queues, wait queues.

Single-level queues– Implemented as array

Fixed size Efficient for simple FIFO operations

– Implemented as linked list Unbounded size More overhead, but more flexible operations

Single-Level Queues

Circular Array Implementation

Link List Implementation

Priority Queues

Array indexed by

priority

Priority Queues

Binary heap of priority

Priority Queues

Binary heapof priority

Array implementation of

binary heap

Threads

MemoryMemory

Address SpacesVirtual Memory

Lowest Address, e.g., 00000000

Highest Address, e.g., FFFFFFFF

MemoryMemory

Address SpacesVirtual Memory

Lowest Address, e.g., 00000000

Highest Address, e.g., FFFFFFFF

UserPrograms

Starting Address of all processes

Processes

UserPrograms

Only one process can be activated at a time.

Process 1Process 1

Process 2Process 2

Process nProcess n

Each process thinks that it owns all memory.

Their address spaces are different.

Context Switching

UserPrograms

Process 1Process 1

Process 2Process 2

Process nProcess n

ContextSwitching

Context Switching

UserPrograms

Process 1Process 1

Process 2Process 2

Process nProcess n

The context switching among processes, i.e., to change address space, is very time

consuming.

The context switching among processes, i.e., to change address space, is very time

consuming.

UserPrograms

Process 1Process 1

Process 2Process 2

Process nProcess n

Threads Each process can have multiple threads. They share the same address space. The context switching among threads in

the process is efficient. Lightweight process Mesa

Processes and Threads

Process has one or more threads

All threads in a process share:

– Memory space

– Other resources

Each thread has its own:

– CPU state(registers, program counter)

– Stack

Threads are efficient, but lack protection from each other

OS Support for Processes/Threads

Create a new Process/thread Initiate or make a thread ready Destroy or terminate a thread Delay or put a thread to sleep for a given

amount of time Synchronize threads through semaphore,

events, or condition variables Perform lower-level operations, such as

blocking, suspending, or scheduling a thread.

Microsoft Windows

Process & Thread Functions

ImplementingProcesses and Threads

Process and Thread Descriptors

System needs some data structures to keep track the state and miscellaneous information, e.g., identification, resources used, accounting information, of processes and treads.

In the following, we are dealing with a system composed solely of processes, much of concept will also apply to threads.

Process Control Block (PCB)

Process IdentificationA system-wide unique

identifier.

A system-wide unique identifier.

State Vector

CPU’s State

Contain necessary data, e.g., program counter, data register, and flag

register, to restart the process at

the point of last interruption.

Contain necessary data, e.g., program counter, data register, and flag

register, to restart the process at

the point of last interruption.

Processor ID

To identify the processor that is executing the process. Make sense only for multiprocessor

system.

To identify the processor that is executing the process. Make sense only for multiprocessor

system.

Memory

Memory map information.

Physical Memory Virtual

Memory

Memory map information.

Physical Memory Virtual

Memory

Status

runningready

blocked

Point to the list, e.g., ready list or wait list, on which the process may

reside.

Point to the list, e.g., ready list or wait list, on which the process may

reside.

More on Status Basic process status

– running, ready, and blocked State transition diagram

readyreadyblockedblocked

runningrunning

SchedulerRequest

Release

Create

Process Activation and Suspension

Some applications require a process (or thread) can be suspended by programs.

For examples– Suspension of a debugging program

– Needed by the internal, e.g., to detect or prevent a deadlock.

Suspend Thread

Resume Thread

The Finer State Transition Diagram

ActiveProcesses

SuspendedProcesses

Creation Tree KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

user j login user n login

userprocesses

childprocesses

KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

Creation Tree KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

Point to the PCB of the parent process.

A link list of PCBs of the child processes

Priority

Used by scheduler to decide which

process should be running next.

Used by scheduler to decide which

process should be running next.

Two methods: Single-integer value Two-leveled valued

– Base priority + Changeable part

PriorityTwo methods: Single-integer value Two-leveled valued

– Base priority + Changeable part

Windows NT priority classes

Others CPU time used Time remaining Resource used Resource claimed Resource quotas Number of I/O requests since creation . . .

Processes and Threads (Windows 2000)

ProcessObject

Handle Table

VAD VAD VAD

object

Virtual Address Space Descriptors

Access Token

Thread Thread Thread . . .Access Token

Windows 2000 (EPROCESS)

Executive Process

Kernel Process Block

Processes and Threads (Windows 2000)

EPROCESS

ETHREAD

Windows 2000 (ETHREAD)

Kernel Thread Block

Windows 2000 Thread States

Implement Operations on Processes

Create– Establish a new process

Destroy– Remove one or more process

Suspend– Change process status to suspended

Activate– Change process status to active

cobegin/coend

forall

fork/join/quit

. . . . . .

Implement Operations on Processes

Create– Establish a new process

Destroy– Remove one or more process

Suspend– Change process status to suspended

Activate– Change process status to active

Operating on PCBs

CSs must be cared

Create

CreateCreate(s0, m0, pi, pid) { p = Get_New_PCB(); pid = Get_New_PID(); p->ID = pid; p->CPU_State = s0; p->Memory = m0; p->Priority = pi; p->Status.Type = ’ready_s’; p->Status.List = RL; p->Creation_Tree.Parent = self; p->Creation_Tree.Child = NULL; insert(self-> Creation_Tree.Child, p); insert(RL, p); Activate(); Scheduler();}

pid = Get_New_PID();

ready_s RLself NULL

Get_New_PCB();

ready_s RLself NULL

Get_New_PCB(); s0

ready_s RLself NULL

Get_New_PCB();

The calling process

ready_s RLself NULL

Get_New_PCB(); s0

ready_s RLself NULL

Get_New_PCB();

Suspend

Suspend KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

Suspend ( )

Suspend?

We choose not.

SuspendSuspend(pid) { p = Get_PCB(pid); s = p->Status.Type; if ((s==’blocked_a’)||(s==’blocked_s’)) p->Status.Type = ’blocked_s’; else p->Status.Type = ’ready_s’; if (s==’running’) { cpu = p->Processor_ID; p->CPU_State = Interrupt(cpu); Scheduler(); } }

Suspend(pid) { p = Get_PCB(pid); s = p->Status.Type; if ((s==’blocked_a’)||(s==’blocked_s’)) p->Status.Type = ’blocked_s’; else p->Status.Type = ’ready_s’; if (s==’running’) { cpu = p->Processor_ID; p->CPU_State = Interrupt(cpu); Scheduler(); } }

returns all registers’ values of the cpu and frees the cp

Activate

Activate KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

Activate ( )

Activate?

We choose not.

Activate

Activate(pid) {

p = Get_PCB(pid);

if (p->Status.Type == ’ready_s’) {

p->Status.Type = ’ready_a’;

Scheduler();

p->Status.Type = ’blocked_a’;

Activate(pid) {

p = Get_PCB(pid);

if (p->Status.Type == ’ready_s’) {

p->Status.Type = ’ready_a’;

Scheduler();

p->Status.Type = ’blocked_a’;

An optionto do this.

Destroy

We need to release all resources associated with the process.

What special action needs to be taken if the process is running?

Destroy KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

Destroy ( )

Killed?

We choose to kill child processes.

Kill_Tree(p) {

for (each q in p->Creation_Tree.Child)

Kill_Tree(q);

if (p->Status.Type == ’running’) {

cpu = p->Processor_ID;

Interrupt(cpu);

Remove(p->Status.List, p);

Release_all(p->Memory);

Release_all(p->Other_Resources);

Close_all(p->Open_Files);

Delete_PCB(p);

Kill_Tree(p) {

Kill_Tree(q);

Interrupt(cpu);

Delete_PCB(p);

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

subroutineKill_Tree ( )

killed

Marked the corresponding cpu free.Marked the corresponding cpu free.

Kill_Tree(p) {

Kill_Tree(q);

Interrupt(cpu);

Delete_PCB(p);

Kill_Tree(p) {

Kill_Tree(q);

Interrupt(cpu);

Delete_PCB(p);

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

subroutineKill_Tree ( )

killed

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

KernelKernel

p1p1p1p1 pn

pnpnpn

q1q1q1q1 qm

qmqmqm

. . . . . .

OS process

user 1 login

pjpjpjpj

userprocesses

childprocesses

Destroy ( )

Kill_Tree(p) {

Kill_Tree(q);

Interrupt(cpu);

Delete_PCB(p);

Kill_Tree(p) {

Kill_Tree(q);

Interrupt(cpu);

Delete_PCB(p);

Destroy(pid) {

p = Get_PCB(pid);

Kill_Tree(p);

Scheduler();

Destroy(pid) {

p = Get_PCB(pid);

Kill_Tree(p);

Scheduler();

ImplementingSync/Comm Mechanisms

General Resource Access Scheme

Semaphores, locks, monitors, messages, time, and other hardware and software objects are considered resources.

Request(res) { if (Free(res)) Allocate(res, self) else { Block(self, res); Scheduler(); }}

Release(res) { Deallocate(res, self); if (Process_Blocked_in(res,pr)) { Allocate(res, pr); Unblock(pr, res); Scheduler(); }}

Implementing Semaphores/Locks

CPU usually doesn’t support P and V operations directly.

Test-and-Set instruction supported mostly– It atomically tests and modifies the contents of a memor

y location.– It can be used to implement general semaphores in multi

processor systems. In uniprocessor systems, it is sufficient to disable i

nterrupts before accessing a semaphore.

The Story (80x86)

Memory

The Story (80x86)

Memory

source

The Story (80x86)

Memory

source

Lock XCHG

The Story (80x86)

Memory

source

The Story (80x86)

Memory

source

Lock XCHG

The spin locks

The Story (80x86)

Memory

source

Lock XCHG

The spin locks

The Story (80x86)

Memory

source

The spin locks

The Story (80x86)

Memory

source

Lock XCHG

The spin locks

Test-and-Set CPU Instruction

TS(R, X)A CPU Register

A Memory Location(Lock Value)

R = X;

X = 0;

Read (test) lock value

Lock (set) the lock

0: locked is locked

1: locked is unlocked

Returns the value in R.

The lock is always locked after being called.

Indivisible

Atomic

Spin Locks on Binary Semaphore

Request( res ) { if (Free(res)) Allocate(res, self) else { Block(self, res); Scheduler(); }}

Release( res ) { Deallocate(res, self); if (Process_Blocked_in(res,pr)) { Allocate(res, pr); Unblock(pr, res); Scheduler(); }}

sb {0, 1}

Request( res ) { if (Free(res)) Allocate(res, self) else { Block(self, res); Scheduler(); }}

Release( res ) { Deallocate(res, self); if (Process_Blocked_in(res,pr)) { Allocate(res, pr); Unblock(pr, res); Scheduler(); }}

sb {0, 1}

Pb VbSb SbSb==1 Sb=1;

wait until Sb==1

sb {0, 1}

Pb(Sb) { do TS(R, Sb) while(!R);/* wait loop */

Vb(Sb) { Sb=1;}

sb {0, 1}

Pb(Sb) { do TS(R, Sb) while(!R);/* wait loop */

Vb(Sb) { Sb=1;}

General Semaphores w/ Busy Wait

P(s) { Inhibit_Interrupts; Pb(mutex_s); s = s-1; if (s < 0) { Vb(mutex_s); Enable_Interrupts; Pb(delay_s); } Vb(mutex_s); Enable_Interrupts;}

V(s) { Inhibit_Interrupts; Pb(mutex_s); s = s+1; if (s <= 0) Vb(delay_s); else Vb(mutex_s); Enable_Interrupts;}

Disallowing Preemption

High Prioritye.g., ISR

Low PriorityLow Priority

Shared Resourc

Dead Lock Condition

Shared Resourc

Dead Lock Avoidance

Shared Resourc

Windows uses different implementations.

Disallowing PreemptionP(s) { Inhibit_Interrupts; Pb(mutex_s); s = s-1; if (s < 0) { Vb(mutex_s); Enable_Interrupts; Pb(delay_s); } Vb(mutex_s); Enable_Interrupts;}

V(s) { Inhibit_Interrupts; Pb(mutex_s); s = s+1; if (s <= 0) Vb(delay_s); else Vb(mutex_s); Enable_Interrupts;}

Disallowed to be preempted by a higher-

priority process.

Disallowed to be preempted by a higher-

priority process.

Interrupt InhibitionP(s) { Inhibit_Interrupts;; Pb(mutex_s); s = s-1; if (s < 0) { Vb(mutex_s); Enable_Interrupts;; Pb(delay_s); } Vb(mutex_s); Enable_Interrupts;;}

V(s) { Inhibit_Interrupts;; Pb(mutex_s); s = s+1; if (s <= 0) Vb(delay_s); else Vb(mutex_s); Enable_Interrupts;;}

UniprocessorP(s) { Inhibit_Interrupts;; Pb(mutex_s); s = s-1; if (s < 0) { Vb(mutex_s); Enable_Interrupts;; Pb(delay_s); } Vb(mutex_s); Enable_Interrupts;;}

Busy WaitP(s) { Inhibit_Interrupts;; Pb(mutex_s); s = s-1; if (s < 0) { Vb(mutex_s); Enable_Interrupts;; Pb(delay_s); } Vb(mutex_s); Enable_Interrupts;;}

Avoiding Busy Wait

P(s) { Inhibit_Interrupts;; Pb(mutex_s); s = s-1; if (s < 0) { Block(self, Ls); Vb(mutex_s); Enable_Interrupts;; Scheduler(); } else { Vb(mutex_s); Enable_Interrupts; }}

V(s) { Inhibit_Interrupts;; Pb(mutex_s); s = s+1; if (s <= 0) { Unblock(q, Ls); Vb(mutex_s); Enable_Interrupts; Scheduler(); } else{ Vb(mutex_s); Enable_Interrupts; };}

Implementing Monitors (Hoare)

Internal Data Internal Data

Condition VariablesCondition Variables

Procedure 1 Procedure 1

c.wait

c.signal

mutually exclusive access for processes

Need a mutex, say mutex.

Need a semaphore for processes blocked on c, say condsem_c.

Need a semaphore for signaling processes, say urgent.

condcnt_c: #processes wait on c

urgentcnt: #signalers

Initial values: mutex = 1;condsem_c = 0;urgent = 0;

condcnt_c = 0;urgentcnt = 0;

Mutual Access of Processesmonitor QueueHandler{

struct Queue queue;condition itemAvail, freenodeAvail;

void AddToQueue( int val ) {if ( queue is full ) { freenodeAvail.wait;}

. . . add val to the end of the queue . . .itemAvail.signal;

} /* AddToQueue */

int RemoveFromQueue() {if ( queue is empty ) { itemAvail.wait;}

. . . remove value from queue . . .freenodeAvail.signal;return value;

} /* RemoveFromQueue */};

monitor QueueHandler{struct Queue queue;condition itemAvail, freenodeAvail;

} /* AddToQueue */

Mutual Access of Processesmonitor QueueHandler{

struct Queue queue;condition itemAvail, freenodeAvail;

} /* AddToQueue */

monitor QueueHandler{struct Queue queue;condition itemAvail, freenodeAvail;

} /* AddToQueue */

P(mutex)

if(urgentcnt) V(urgent);else V(mutex);

Mutual Access of Processes

Procedure_body

P(mutex)

if(urgentcnt) V(urgent);else V(mutex);

condcnt_c = condcnt_c + 1;

if (urgentcnt) V(urgent);

else V(mutex);

P(condsem_c); /* wait */

condcnt_c = condcnt_c - 1;

wait/signal

c.wait: c.signal:

if (condcnt_c) {

urgentcnt = urgentcnt + 1;

V(condsem_c);

P(urgent); /* wait */

urgentcnt = urgentcnt - 1;}

Clock and Time Management

Why OS needs time?– Performance measurement– Processor Scheduling– Time-Stamping Events

e.g., I/O and file system call

– Deadlock and other fault detection– . . . . . . . .

Clock and Time Management

Most systems provide hardware– ticker: issues periodic interrupt – countdown timer: issues interrupt after a set number of ticks

Build higher-level services with this h/w Wall clock timers

– Typical functions: Update_Clock : increment tnow (invoked each time tick) Get_Time : return current time Set_Time(tnew) : set time to tnew

– Must maintain monotonicity

Countdown Timer (Alarm Clocks)

Processes or threads may need timeout signal at some specified time in the future.

Examples:– Delay an amount of time to wait I/O completion– Sleep to hand over CPU time– Block until awakened by timer signal events

Typical Function:– Delay(tdel) block process for tdel time units

Implementation of Delay(tdel)

To block process for tdel time units.

Implementation using hardware countdown:

semaphore delsem;

Delay(tdel) { Set_Timer(tdel); /*set hardware timer*/ P(delsem); /*wait for interrupt*/}

Timeout() { /*called at interrupt*/ V(delsem);}

Logical Countdown Timers

Implement multiple logical countdown timers using a single hardware timer

Functions:– tn = Create_LTimer() create new timer– Destroy_LTimer(tn)– Set_LTimer(tn, tdel) logically equivalent

to Set_Timer(tdel)

How to implement multiple logical timers?

Priority Queue withAbsolute Wakeup Times

Set_LTimer(tn, tdel)

103103

Wall-clock

Countdown

HardwareTimers

p1 115 p2 135 p3 140 p4 150

TimerQueue

Set_LTimer(??, 35)

103103

Wall-clock

Countdown

HardwareTimers

p1 115 p2 135 p3 140 p4 150

TimerQueue

p5 138 p3 140 p4 150p1 115 p2 135TQ

+103+138

103103

Wall-clock

Countdown

HardwareTimers

p5 138 p3 140 p4 150p1 115 p2 135TQ

104104 1111105105 1010106106 99107107 88108108 77109109 66110110 55111111 44112112 33113113 22114114 11115115 00

115115

p2 135

Wall-clock Countdown

HardwareTimers

p5 138 p3 140 p4 150p2 135TQ

115115 00

135-115

Priority Queue with Time Differences

Countdown

HardwareTimer

p1 15 p2 20 p3 5 p4 10

TimerQueue

Set_LTimer(tn, tdel)

Countdown

HardwareTimer

Set_LTimer(??, 35)

p5 3 p3 2 p4 10p1 15 p2 20TQ

p1 15 p2 20 p3 5 p4 10

TimerQueue

Countdown

HardwareTimers

p5 3 p3 2 p4 10p1 15 p2 20TQ

1111101099887766554433221100

Countdown

HardwareTimers

p5 3 p3 2 p4 10p2 20

MemoryMemoryMemoryMemoryProcess

qProcess

Communication Primitives

Address space for process q

Address space for process p

System Space

User Space

The same physical memory used.

Different physical memory used.

Assume that the communication processes are in the same machine.

OSOS OSOS

Process

qProcess

pProcess

Communication

send/receive

Communication

send/receive

send/receive can be blocked or nonblocked.

OSOS OSOS

Process

qProcess

pProcess

send(p,m)

receive(q,m)

OSOS OSOS

Process

qProcess

pProcess

send(p,m) receive(q,m)

sbufrbuf

Different address mappings for p and q.

send(p,m)

OSOS OSOS

Process

qProcess

pProcess

send(p,m)

sbuf’ sbuf’

send(p,m)

OSOS OSOS

Process

qProcess

pProcess

receive(q,m)

sbufrbuf

sbuf’ sbuf’

rbuf’rbuf’

send(p,m)

OSOS OSOS

Process

qProcess

pProcess

receive(q,m)

sbufrbuf

sbuf’ sbuf’

rbuf’rbuf’

send(p,m)

OSOS OSOS

Process

qProcess

pProcess

receive(q,m)

sbufrbuf

sbuf’ sbuf’

rbuf’rbuf’

Copying through system buffers(Processes in the same machine)

Use pool of system buffers

Copying accross network(Processes in the different

machines)

Interrupt Handling

Why Interrupt Handling?

Many events occur at an unpredictable time, i.e., asynchronously– Polling is impractical– Transfer of control out of normal process temporarily

upon coming of an event and, then, back.

To remove the notion of asynchronous events from higher levels of kernel, the OS, and applications– Process abstraction: processes are almost to have

independent activities and operating in parallel.– For example, OS and applications don’t deal with I/O

completion event directly.

The program to serve interrupt is called interrupt handler (IH) or interrupt service routine (ISR).

Types of Interrupt

External Interrupts– Generated by hardware– Asynchronous– E.g., I/O completion, time-out, the arrival of

message (network card), …

Internal Interrupts– Generated by software– Synchronous– E.g., Exceptions (instruction errors), SVC

We deal with hardware interrupt in the following.

Interrupt Controller (82C59A)

to CPU

SignaledBy I/O

Devices

SignaledBy I/O

Devices

Interrupt requests are priority-leveled.

IH’s of high-priority events can preempt those of lower priority.

Interrupt requests are maskable.

80x86 uses STI and CLI to temporarily enable and disable all interrupts, respectively.

Interrupt Handling

CPUCPU INT

InterruptController

(e.g., 8259)

InterruptController

(e.g., 8259)

IRQ0IRQ1IRQ2IRQ3IRQ4IRQ5IRQ6IRQ7

Each interrupt has an interrupt service routine (ISR).

. . . . . . . . . .

Normal Job

Interrupt Handling

CPUCPU INT

InterruptController

(e.g., 8259)

InterruptController

(e.g., 8259)

. . . . . . . . . .

Normal Job

Put the value of flag register, and program

counter (PC) into the stack.

PC (*)

Interrupt Handling

CPUCPU INT

InterruptController

(e.g., 8259)

InterruptController

(e.g., 8259)

. . . . . . . . . .

Normal Job

Read Interrupt Vector

Push used registers (PUSHA)

. . . . . . . . . . . . . . . . . . . . . . .

Pop used registers (POPA)

Return from interrupt (IRET)

. . . . . . . . . . . . . . . . . . . . . . .

PC (*)

Interrupt Handling

CPUCPU INT

InterruptController

(e.g., 8259)

InterruptController

(e.g., 8259)

. . . . . . . . . .

Normal Job

. . . . . . . . . . . . . . . . . . . . . . .

PC (*)

Interrupt Handling

CPUCPU INT

InterruptController

(e.g., 8259)

InterruptController

(e.g., 8259)

. . . . . . . . . .

Normal Job

PC (*)

Standard Interrupt Handing Sequence

1. Save state of interrupted process/thread

2. Identify interrupt type and invoke IH

3. IH services interrupt

4. Restore state of interrupted process (or of

another one if the interrupt for awakening a

waiting process)

......

The Typical Sequence for Using a Hardware Device

CPUCPU I/OProcessor

I/OProcessor

Start I/O

Interrupt

......Do_I/O......

InterruptServiceRoutine

The Typical Sequence for Using a Hardware Device

start I/O

Synchronization Primitives Needed

P/Vwait/signal

Monitor: Object-Oriented Approach

Device DriverImplementedUsing monitor

Called by the processes need to do I/O.

Called while I/O completion.

Implementing Using Monitor

Example: Monitor Clock Server

monitor Clock_Server { int tnow; Update_Clock() { . . . tnow = tnow + 1; /* Perhapes update time structure also */ }

int Get_Time() { . . . return(tnow); /* Perhaps return some more complex structure instead */ }

Set_Clock(int tnew) { . . . tnow = tnew; }}

Operating Systems Principles Process Management and Coordination Lecture 4: The Operating System...

Documents

Transcript of Operating Systems Principles Process Management and Coordination Lecture 4: The Operating System...

Using Threads

ThreadsCS-3013 C-term 20081 Threads CS-3013, Operating Systems C-Term 2008 (Slides include materials from Operating System Concepts, 7 th ed., by Silbershatz,

THREADS - cin.ufpe.br

07 Threads Cont

Operating Systems Principles Process Management and Coordination Lecture 3: Higher-Level Synchronization and Communication 主講人：虞台文.

Processes and Threads (1/2) - NTUATitle Processes and Threads (1/2) Author Vangelis Koukis Subject Operating Systems Course, CSLab - NTUA Created Date 3/5/2018 9:59:40 AM

Operating Systems Principles Process Management and Coordination Lecture 5: Process and Thread Scheduling 主講人：虞台文.

Po Six Threads

Slide 6-1 Copyright © 2004 Pearson Education, Inc. Operating Systems: A Modern Perspective, Chapter 6 Implementing Processes, Threads, and Resources.

5장 스레드 ( Threads)

Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory 主講人：虞台文.

Chapter 4: Threads

Cours 11 Threads. Chapitre X threads threadPOO-L3 H. Fauconnier3 Threads threads: plusieurs activités qui coexistent et partagent des données exemples:

Operating Systems Principles Memory Management Lecture 8: Virtual Memory 主講人：虞台文.

No threads

Operating Systems Principles Process Management and Coordination Lecture 6: Deadlocks 主講人：虞台文.

SMP und Threads

Multi threads

Processus et threads

Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Chapter 4: Threads.