INTRODUCTION

TO

OPERATING SYSTEMS

Lecture 4: THE KERNEL OF THE OPERATING SYSTEM (2)

CHRIS STAFF
Dept. of Computer Science and Artificial Intelligence
University of Malta

Next Lecture: Input and Output

Lecture Outline

Aims and Objectives
Interprocess Communication
Implementing Wait and Signal
The Dispatcher (Low-Level Scheduler)
Summary

Aims and Objectives

Interprocess Communication
Implementing Semaphores

Interprocess Communication

Processes need to be able to communicate with each other.

Process A may require that Process B prepares data for it before it can continue executing
Dijkstra (1965) - introduced concept of Semaphores
A semaphore is a non-negative integer which, apart from initialisation, can only be operated on by the primitive operations, wait and signal.
Signal(semaphore) indivisibly increments value of the semaphore by 1.
Wait(semaphore) indivisibly decrements the value of the semaphore by 1, IFF the result would be non-negative. Otherwise, the operation is queued.

Using semaphores to ensure Mutual Exclusion.

E.g., To Prevent multiple access to a non-shareable resource, make part of program Critical Section.
Initial value of semaphore can be any non-negative integer, but value of 1 ensures mutual exclusion - Binary Semaphore.
Process Synchronisation achieved by implementing Binary Semaphore with an initial value of 0. Process A waits for Semaphore to be greater than 0. Process B signals semaphore when data prepared / operation complete.
Counting semaphore used to keep count of the number of times Critical Section can be entered. Initial Value equal to, say, number of similar resources available.
Example - Producer / Consumer Problem
P1 adds items to Buffer (Producer); P2 takes items from Buffer (Consumer). Buffer of limited size, N.
P1 cannot add items if buffer is full
P2 cannot take items if buffer is empty

Synchronising processes

Program for Producer Program for Consumer
Repeat indefinitely

produce item;

wait(space available);

wait(Buff. Manip.);

deposit item in buffer;

signal(Buff. Manip);

signal(item available);
end
Repeat indefinitely

wait (item available);

wait(Buff. Manip.);

extract item from buffer;

signal(Buff. Manip);

signal(space available);

consume item;
end

Re-order waits and signal to create deadlock problem.
Hoare's solution of Monitors reduces deadlock problem.

Program for Producer	Program for Consumer
Repeat indefinitely produce item; wait(space available); wait(Buff. Manip.); deposit item in buffer; signal(Buff. Manip); signal(item available); end	Repeat indefinitely wait (item available); wait(Buff. Manip.); extract item from buffer; signal(Buff. Manip); signal(space available); consume item; end

Implementing Wait and Signal

Wait and Signal are implemented in Kernel because:

they must be available to all processes;

wait may result in current process being made unrunnable, and Kernel must select another;

convenient for interrupt to make a process runnable by signalling a semaphore

The Dispatcher (Low-Level Scheduler)

Dispatcher entered every time current process cannot continue, or another process would be better to run.
On an interrupt, Dispatcher always responds to an interrupt - the context of the current process will be saved (FLIH) and the next runnable process to run (which may be the process that was just interrupted) will be selected.
The High-Level Scheduler decides the order in which processes should be selected by the Low-Level Dispatcher.

Summary

Described Interprocess Communication & Synchronisation through Semaphores
Looked at the way in which Wait & Signal are implemented
Seen how runnable processes are selected for execution by the Dispatcher

Next Lecture...

Input and Output