Systeem-ge ï ntegreerde Programmatuur

Systeem-geïntegreerde programmatuur Yolande Berbers

SGP Systeem-geïntegreerde Programmatuur

Systeem-geïntegreerde Programmatuur

Marc Gobin (&Yolande Berbers)

Departement Computerwetenschappen

(200A 03.20)([email protected])

SGP

slide 2Systeem-geïntegreerde programmatuur Yolande Berbers

practische organisatie

Marc Gobin is ziek ik geef enkele weken les

zeker 2, waarschijnlijk 3, misschien meer slides kun je vinden via mijn home-page

http://www.cs.kuleuven.ac.be/~yolande/

lessen over device drivers die geef ik al altijd

practica: zie verder

SGP


overzicht van de cursus

karakteristieken van real-time systemen

Ada en Java voor real-time en embedded systemen

gelijktijdige processen

het invoeren van tijd

interrupts

device drivers

petri-netten

schedulability

temporele logica

SGP


practica

2 practica practicum 1

individueel schrijven van een programma dat gebruik maakt van

gelijktijdige taken begroot op 10 uur

practicum 2 in groepjes van 2 schrijven van pakket voor communicatie tussen 2 pc’s begroot op 20 uur

er wordt een demo van de 2 practica georganiseerd timing is afhankelijk van verloop herstel Marc Gobin



deel 3concurrent programming:

tasks

SGP


concurrent programming: inleiding

concurrent programming = notaties en technieken voor

uitdrukken van potentieel parallellisme

oplossen van synchronisatie en communicatie

concurrent programming biedt

abstractiemechanismen om parallellisme te beschrijven

onafhankelijk van de implementatiedetails

de implementatie van parallellisme

onderwerp van computersystemen (hardware en software)

is onafhankelijk van concurrent programming

SGP


proces, controledraad sequentiële programmeertalen: Pascal, C, Fortran, COBOL

programma’s hebben slechts 1 controledraad (Engels: thread) ze voeren uit, bevel per bevel, totdat het programma eindigt het pad door het programma kan variëren al naar gelang de

invoer, maar bij gelijke invoer heb je een gelijk pad ‘concurrent’ programmeertalen (programmeertalen voor

gelijklopende onderdelen) bevatten de notie van proces elke proces heeft (tenminste) 1 controledraad implementatie van processen:

uitvoering op 1 enkele processor (multiprogrammatie) uitvoering op multiprocessor (met gedeeld geheugen) uitvoering op multicomputer (met gescheiden geheugen)

concurrent slaat op potentieel parallellisme

SGP


levencyclus van een proces

niet bestaand

uitvoerbaar

beëindigd

gecreëerd

initialiserend

SGP


proces, controledraad

RTSS (run-time support system) heeft de taak van het creëren en initialiseren van een proces

eventueel ook van het schedulen van de verschillende

controledraden

wordt meestal door de compiler gegenereerd

alternatief voor concurrent programmeertalen gescheiden processen schrijven met een sequentiële taal

de mogelijkheden van het besturingssysteem gebruiken om

gelijktijdige uitvoering te bekomen

SGP


proces, controledraad processen

worden voorzien in alle besturingssystemen elke proces voert uit in een eigen virtuele machine, zonder

interferentie van andere processen (logisch gezien alsof ze het enige proces zijn)

controledraden (threads) soort subproces binnen een klassiek proces alle controledraden hebben toegang tot gehele virtuele machine de programmeur en de taal moeten de controledraden voor

elkaar beschermen discussie: op welk niveau moet concurrency aangeboden

worden: door de taal of door het besturingssysteem ? Ada en Java bieden concurrency in de taal C en C++ niet

SGP


proces, controledraad

voordelen van concurrent programmeertalen beter leesbare en onderhoudbare code draagbaarder over meerdere besturingssystemen heen soms is er geen besturingssysteem op een real-time systeem de compiler kan op een aantal zaken testen

voordelen combinatie sequentiële taal + besturingssyst gemakkelijker om programma's geschreven in verschillende

talen te combineren op sommige besturingssystemen is het moeilijk om sommige

concurrent taalmodellen te implementeren omdat er standaarden zijn voor besturingssystemen, zijn de

programma's draagbaarder

SGP


constructies voor concurrent programmeren

3 fundamentele faciliteiten uitdrukken van gelijktijdig uitvoeren (door de notie van proces)

synchronisatie tussen processen

communicatie tussen processen

3 verschillende soorten relaties onafhankelijk

samenwerkend

in competitie

SGP


gelijktijdig uitvoeren

verschillen tussen procesmodellen structuur

niveau

granulariteit

initialisatie

beëindiging

relaties tussen gecreëerd proces en andere

voorstelling

SGP



structuur statisch

aantal processen is vast dit aantal is gekend tijdens compilatie

dynamisch aantal processen kan variëren van uitvoering tot uitvoering

niveau vlak

processen enkel gedefinieerd op hoogste niveau genest

processen kunnen een hiërarchie vormen: processen kunnen andere processen starten (vader/kind)

SGP



granulariteit fijn

het is ‘goedkoop’ om processen te creëren in een typisch programma worden er veel gecreëerd voor

telkens een hele kleine taak grof

het is ‘duur’ om een proces te creëren er worden geen grote aantallen processen gecreëerd

initialisatie parameters doorgeven expliciete communicatie na creatie

SGP



beëindiging beëindigen van de code door uitvoering van een specifiek ‘zelfmoord’ bevel expliciete moord door een ander proces uitvoering van een niet-opgevangen uitzondering nooit (oneindige lus) wanneer niet meer nodig (geen communicatie meer mogelijk)

relatie tussen gecreëerd proces en andere vader/kind: vader (creërend proces) wacht tot het kind

gecreëerd en geïnitialiseerd is hoeder/afhankelijke: hoeder kan niet het blok verlaten waarin de

afhankelijke is gecreëerd, voordat de afhankelijke beëindigd is vader en hoeder kunnen maar hoeven niet zelfde proces te zijn

SGP


levencyclus van een proces

wacht opinit kind

niet bestaand

uitvoerbaar

beëindigd

gecreëerd

initialiserend

wacht opafhank. einde

SGP



terminologie bij object-georiënteerde systemen elke proces is een object (maar niet omgekeerd) actieve objecten: nemen spontaan acties reactieve objecten

reageren enkel op invocaties (= operaties die uitgevoerd worden op een object)

bv resources (hulpmiddelen) passieve objecten

reactieve objecten waarvan de operaties altijd kunnen uitgevoerd worden

beschermde resource: resource beschermd door een passieve entiteit

server: resource waarbij de controle actief is (proces is nodig)

SGP



voorstelling: 4 basis mechanismen

co-routines

fork/join

cobegin/coend

expliciete procesdeclaratie

SGP


procesvoorstelling: co-routines

controle wordt expliciet doorgegeven (sleutelwoord

resume): er is geen return-bevel

relatie is symmetrisch

een routine A voert ‘resume B’ uit

routine A stopt uitvoeren

routine B voert uit vanaf het punt waar het vroeger gestopt was

routine A bewaart alle statusinformatie, zodat het later op

hetzelfde punt kan verder gezet worden

SGP


procesvoorstelling: co-routines

Co-routine A Co-routine B Co-routine C

resume B

resume B

resume C

resume C

resume A

resume A

resume B

1 2 3 4 5 6

6

7 8 9

10

1112

1312

14

15

SGP


procesvoorstelling: fork en join

methode: C := fork F een nieuw proces start de uitvoering van F

oproepend proces gaat ook verder join C; oproepend proces wacht op einde F

gebruikt in POSIX bij fork kun je parameters doorgeven met wait wacht je, 1 waarde keert terug flexibel maar niet erg gestructureerd

geven gemakkelijk aanleiding tot fouten hoeder moet bijvoorbeeld expliciet wachten op al zijn

kinderen

SGP


procesvoorstelling: fork en join

tijdsasfork fork

join

join

P F P F

vaderproces voert join uit voordat kind beëindigd is

kindproces heeft gedaan voordat vader join uitvoert

SGP


procesvoorstelling: cobegin/coend

na cobegin (of parbegin) staan een aantal blokken die in

parallel uitgevoerd worden (ze worden allemaal samen

opgestart)

het vaderproces wacht, of voert 1 van de blokken uit

bij coend (of parend) wordt er gewacht tot alle blokken

beëindigd zijn

SGP


procesvoorstelling: cobegin/coend

tijdsas

coend

cobegin

SGP


procesvoorstelling: ex-/impliciete procesdeclaratie

expliciete procesdeclaratie

routines geven tekstueel aan of ze door een apart proces

uitgevoerd worden (modula 1)

het is niet meer de oproeper van de routine die aangeeft dat

een nieuw proces gecreëerd moet worden

impliciete procesdeclaratie

alle processen die gedeclareerd worden binnen een blok

beginnen in parallel uit te voeren bij begin van het blok (Ada)

SGP


gelijktijdige uitvoering in Ada

benaming voor sequentieel proces: task kan gedeclareerd worden wordt gecreëerd wanneer declaratie zichtbaar wordt: impliciet procedure eenvoudige_taak eindigt niet voordat task A eindigt

procedure eenvoudige_taak istask A;task body A is

-- lokale declaratiesbegin

-- bevelen van de taak Aend A;

begin... -- taak A begint met uitvoeren voor het eerste bevel in dit blok

end eenvoudige_taak;

SGP



het is mogelijk een task-type te definiëren maakt het mogelijk om een rij van taken te declareren

task type T;

type Long is array (1..100) of T;

L: Long;

task body T is

-- lokale declaraties

begin

-- bevelen van de taak T

end T;

SGP



parameters kunnen doorgegeven worden bij initialisatieprocedure Main is

type Dimension is (Xplane, Yplane); task type Control (Dim: Dimension);C1: Control(Xplane);C2: Control(Yplane);task body Control is

-- lokale declaratiesbegin

-- bevelen van de taak Control (zie in boek)end Control;

begin null;

end Main;

SGP



uitzonderingen bij initialisatie: de creërende taak krijgt de uitzondering

‘Tasking_error’

tijdens uitvoering:

de nieuwe taak mag de uitzonderingen opvangen

niet opgevangen uitzondering: nieuwe taak wordt beëindigd

beëindiging van een taak de taak beëindigt zijn uitvoering (normaal of door uitzondering)

de taak voert het bevel ‘terminate’ uit (zie later)

de taak is gestopt door een andere taak (via abort)

SGP


gelijktijdige uitvoering in POSIX

twee mechanismen voor processen

fork() creëert een exacte copie van het oproepende proces met wait() kan het oproepende proces wachten op het

gecreëerde voor threads

allerhande routines voor creatie en beheer van threads vaak met veel parameters nogal complex

beide mechanismen situeren zich op het niveau van het besturingssysteem (zijn dus niet in een taal geïntegreerd)

SGP



threads in POSIX alle threads hebben attributen (vb stack size)

attribute object om deze attributen te manipuleren

typedef … pthread_t;

typedef … pthread_attr_t;

int pthread_attr_init (pthread_attr_t *attr);

/* initializes a thread attribute pointed at by attr to default values */

int pthread_setstacksize (pthread_attr_t *attr, size_t stacksize);

/* set the stack size of a thread attributed */

int pthread_attr_setstrackaddr (pthread_attr_t *attr, void *stackaddr);

/* set the stack address of a thread attribute */

SGP



threads in POSIX alle threads hebben een identifier, uniek in het proces

thread kan deze identifier bekomen via pthread_self

typedef … pthread_t;

pthread pthread_self (void);

/* return the thread_id of the calling thread */

int pthread_equal (pthread_t t1, pthread_t t2);

/* compare two thread ids */

SGP



threads in POSIX thread is klaar om uit te voeren na creatie

pthread_create, 4 argumenten: thread identifier, attributes, functie met de code, parameters die doorgegeven moeten worden

int pthread_create (pthread_t *thread,

const pthread_attr_t *attr,

void * (*start_routine) (void*),

void *arg);

/* create a new thread with the given attributes and call the

given start_routine with the given argument */

SGP



threads in POSIX thread kan eindigen

door oproep van pthread_exit bij ontvangst van een signal (zie hoofdstuk 10) gestopt door pthread_cancel

int pthread_exit (void *value_ptr);

/* terminate the calling thread and make the pointer value_ptr

available to any joining thread */

SGP



threads in POSIX wachten op het einde van een andere thread: pthread_join

int pthread_join (pthread_t thread, void **value_ptr);

/* suspends the calling thread until the named thread has

terminated, and returned values are pointed at by

value_ptr */

SGP



threads in POSIX opkuisen na uitvoering en vrijgave van geheugen:

bij join met detach attribute: geen join nodig

int pthread_attr_setdetachstate (pthread_attr_t *attr,

int *detachstate);

/* set the detach state of the attribute */

int pthread_detach (pthread_t thread);

/* the storage space associated with the given thread may be

reclaimed when the thread terminates */

SGP


een eenvoudig real-time systeem

aflezen van temperatuur en aanpassen van verwarming aflezen van druk en aanpassen van pomp telkens de waarden ook op het scherm printen

P

T

S

thermokoppel

verwarming

drukmeter

pomp

scherm

SGP



3 implementatiemethoden 1 sequentieel programma

houdt geen rekening met het feit dat T, P en S logisch gezien gelijktijdig en onafhankelijk van elkaar zijn

vraagt geen ondersteuning van het run-time- of besturingssysteem

3 sequentiële programma's T, P en S zijn geschreven in een sequentiële taal met primitieven van het besturingssysteem worden 3

processen hiervoor gecreëerd 1 concurrent programma

T, P en S zijn 3 threads run-time ondersteuning is nodig

SGP


een eenvoudig real-time systeem 1 sequentieel programma, houdt geen rekening met feit dat T, P

en S logisch gezien gelijktijdig en onafhankelijk van elkaar zijn

procedure Controller is

TR : Temp_Reading;

PR : Pressure_Reading;

HS : Heater_Setting;

PS : Pressure_Setting;

begin

loop

Read(TR); Temp_Convert(TR, HS); Write(HS); Write(TR);

Read(PR); Pressure_Convert(PR, PS); Write(PS); Write(PR);

end loop;

end Controller;

SGP



1 sequentieel programma: bespreking temperatuurmetingen en drukmetingen gebeuren met gelijke

intervallen (misschien hoeft dat niet in de praktijk) mogelijke oplossing: een aantal if-then-else bevelen toevoegen

wanneer het programma bezig is met temperatuur kan er geen aandacht gegeven worden aan de druk en vice-versa

als probleem met lezen van 1 van de 2 metingen blokkeert het geheel (dus ook het deel dat daar niets mee te maken heeft)

mogelijke oplossing: testen of er kan gelezen worden (p. 195) nadeel is hier wel dat men test via ‘polling’ (busy waiting) dit vraagt veel processortijd

belangrijkste opmerking: geen weerspiegeling van werkelijkheid, waar temperatuur en druk volledig onafhankelijke subsystemen zijn

SGP


een eenvoudig real-time systeem 3 sequentiële programma's (met primitieven van het

besturingssysteem worden 3 processen hiervoor gecreëerd)

package Operating_System_Interface is

type Thread_Id is private;

type Thread is access procedure;

function Create_Thread (Code: Thread) return Thread_Id;

...

end Operating_System_Interface;

package processes is

procedure Temp_Controller;

procedure Pressure_Controller;

end processes;

package body processes is ...

SGP


een eenvoudig real-time systeem 3 sequentiële programma's (met primitieven van het

besturingssysteem worden 3 processen hiervoor gecreëerd)


TC, PS: Thread_Id;

begin

TC := Create_Thread (Temp_Controller’Access);

PC := Create_Thread (Pressure_Controller’Access);

end Controller; bespreking

doordat de taal geen ondersteuning biedt is dit moeilijk te schrijven en te onderhouden (zeker voor grotere systemen)

bv niet erg duidelijk uit de code welke procedures nu gewone zijn en welke bedoeld zijn om als proces uit te voeren

SGP


een eenvoudig real-time systeem 1 concurrent programma waarbij T, P en S 3 threads zijn


task Pressure_Controller;

task Temp_Controller;

task body Temp_Controller is

begin loop

Read(TR); Temp_Convert(TR, HS); Write(HS); Write(TR);

end loop;

end Temp_Controller ;

task body Pressure_Controller is ...

begin

null;

end Controller ;

SGP



1 concurrent programma: bespreking de logica van de toepassing is mooi zichtbaar in de code dit maakt het geheel leesbaar en onderhoudbaar

probleem dat telkens genegeerd werd: synchronisatie van de data die naar het scherm gestuurd worden (zie hoofdstuk 8)




synchronisatie en communicatie met gedeelde variabelen

SGP


overzicht probleemstelling: kritische sectie en conditionele

synchronisatie vb kritische sectie: verhogen van een gedeelde variabele met 1 vb conditionele synchronisatie: producent/consument met buffer verondersteld gekend

oplossing 1: busy waiting, suspend/resume: kort oplossing 2: semaforen oplossing 3: conditionele kritische secties oplossing 4: monitors protected objects: oplossing van Ada

SGP


ondersteuning voor semaforen

Ada geen directe ondersteuning in de taal

gemakkelijk om een package te maken die het aanbiedt voor

gebruik tussen taken

8.4.5: klassiek voorbeeld van producer/consumer in Ada

C geen ondersteuning

POSIX tellende semaforen tussen aparte processen en voor

verschillende threads in een proces

SGP


standard operations for counting semaphores initialize, wait, signal

typedef … sem_t;

int sem_init (sem_t *sem_location, int pshared, unsigned int value);

/* initializes the semaphore at location sem_location to value

pshared determines if used between processes or threads or

only between threads of the same process */

int sem_wait (sem_t *sem_location);

/* a standard wait operation on a semaphore */

int sem_post (sem_t *sem_location);

/* a standard signal operation on a semaphore */

POSIX semaphores

SGP


int sem_trywait (sem_t *sem_location);

/* attempts to decrement the semaphore

returns -1 if the call might block the calling process */

int sem_getvalue (sem_t *sem_location, int *value);

/* gets the current value of the semaphore to a location

pointed at by value */

POSIX semaphores

non-standard operations for counting sem. non-blocking wait, determining value of sem.

SGP


nadelen van semaforen

semaforen leiden gemakkelijk tot fouten

(en zijn dus ongeschikt in real-time programmatuur)

vergeet er 1 en het programma loopt fout

heel moeilijk om te vinden waar precies wait of signal vergeten

deadlock kan gemakkelijk optreden

(misschien maar in heel weinig voorkomende gevallen, maar

dat is juist moeilijk te testen)

SGP


monitors

wat gestructureerde manier om code-segmenten te schrijven met

garantie voor uitvoering onder wederzijdse uitsluiting, en met mogelijkheid tot conditionele synchronisatie

hoe module met een verzameling van kritische secties die elk als

procedure of functie geschreven zijn module heet monitor alle variabelen die beschermd moeten worden zijn verborgen

(information hiding) conditie variabelen voor conditionele synchronisatie

wait: blokkeert altijd het uitvoerende proces signal: deblokkeert een wachtend proces indien er zo één is

SGP


monitor: voorbeeldmonitor buffer;

export append, take;const size = 32;var buf: array[0...suze-1] of integer;

top, base : 0 .. size-1;SpaceAvailable, ItemAvailable : condition;NumberInBuffer : integer;

procedure append (I : integer) .....procedure take (var I : integer) .....

begin (* initialisatie *)NumberInBuffer := 0;top := 0;base := 0

end;

SGP


monitor: voorbeeld

procedure append (I : integer);begin

if (NumberInBuffer = size) then wait (SpaceAvailable);buf[top] := I;NumberInBuffer := NumberInBuffer + 1;top := (top + 1) mod size;signal (ItemAvailable);

end append;procedure take (var I : integer);begin

if (NumberInBuffer = 0) then wait (ItemAvailable);I := buf[base];base := (base + 1) mod size;NumberInBuffer := NumberInBuffer - 1;signal (SpaceAvailable);

end take;

SGP


monitors (commentaar bij voorbeeld)

minstens 2 processen zijn betrokken één producent (maar het kunnen er meerdere zijn) één consument (maar het kunnen er meerdere zijn)

processen kunnen geblokkeerd zijn omdat ze de monitor proberen binnen te gaan

ze proberen append of take uit te voeren omdat ze wachten op een conditie

er is bv geen plaats in de buffer of er zijn geen elementen in de buffer

er is dus een mogelijke wachtrij voor de monitor zelf en voor elke conditievariabele

SGP


monitors

welk proces mag (exclusief) uitvoeren na een signal ? proces dat signal uitvoert (proces dat een wait deed wacht nog even) proces dat een wait deed (proces dat de signal doet moet nu wachten)

mogelijke semantiek voor signal signal mag alleen als laatse instructie voor verlaten van monitor

zoals in het producer/consumer voorbeeld niet erg flexibel

signal heeft als neven-effect een return (dus het uitvoerend proces wordt verplicht de monitor te verlaten)

proces dat signal uitvoert blijft uitvoeren; proces dat gedeblokkeerd is moet daarna weer vechten om de monitor te mogen betreden

proces dat de signal uitvoert blokkeert, en proces dat gedeblokkeerd werd mag direct uitvoeren

SGP


monitors

voordeel van monitors

gestructureerde manier voor het programmeren van

wederzijdse uitsluiting

nadeel van monitors

laag-niveau manier voor het programmeren van conditionele

synchronisatie

SGP


mutexes and condition variables in POSIX

each monitor has an associated (initialized) mutex variable

all operations on the monitor are surrounded by calls to lock

and unlock of the mutes

condition synchronization is provided by associating condition

variables with the mutex

when a thread waits on a condition variable, its lock on the

associated mutex is released

when a thread successfully returns from the conditional wait, it

again holds the lock

SGP


int pthread_mutex_init (pthread_mutex_t *mutex,

const pthread_mutexattr_t *attr);

/* initializes a mutex with certain attributes */

int pthread_mutex_lock (pthread_mutex_t *mutex);

/* lock the mutex; if already locked suspend calling thread

the owner of the mutex is the thread which locked it */

int pthread_mutex_unlock (pthread_mutex_t *mutex);

/* unlock the mutex if called by the owning thread

undefined behavior if the calling thread is not the owner

undefined behavior if the mutex is not locked

when successful, results in release of a blocked thread */


SGP


int pthread_cond_init (pthread_cond_t *cond,

const pthread_condattr_t *attr);

/* initializes a condition variable with certain attributes */

int pthread_cond_wait (pthread_cond_t *cond,

pthread_mutex_t *mutex);

/* called by thread which owns a locked mutex

(undefined behavior if the mutex is not locked)

atomically blocks the calling thread on the cond variable

and releases the lock on mutex

a successful return indicates that the mutex has been locked */

int pthread_cond_signal (pthread_cond_t *cond);

/* unblocks at least 1 blocked thread; no effect if no threads are

blocked; unblocked threads automatically contend for the

associated mutex /*


SGP


int pthread_mutex_trylock (pthread_mutex_t *mutex);

/* the same as lock but gives error return if mutex already locked */

int pthread_cond_timedwait (pthread_cond_t *cond,

pthread_mutex_t *mutex, const st’ruct timespec *abstime);

/* the same as pthread_cond_wait, except that an error is returned

if the timeout expires */


SGP


example: bounded buffer consisting of mutex two condition vairables (buffer_not_full and buffer_not_empty) a count of number of elements the buffer itself the positions of first and last items in buffer routine ‘append’ routine ‘take’


SGP


#define SYS_CALL (A) if (sys_call(A) != 0) error()

/* where error is function which undertakes some error processing */

note: lighter notation for calls in POSIX error conditions from POSIX: return -1 for reliability: every call to system function should test the return

value in book: macro


SGP


# include “pthreads.h”

# define BUFF_SIZE 10

typedef struct {

pthread_mutex_t mutex;

pthread_cond_t buffer_not_full;

pthread_cond_t buffer_not_empty;

int count, first, last;

int buf [BUFF_SIZE];

} buffer;

/* an initialize routine is required */


SGP


int append (int item, buffer *B) {

PTHREAD_MUTEX_LOCK (&B->mutex);

while (B->count == BUFF_SIZE)

PTHREAD_COND_WAIT (&B->buffer_not_full, &B->mutex);

/* put data in buffer and update count and last */

PTHREAD_MUTEX_UNLOCK (&B->mutex);

PTHREAD_COND_SIGNAL (&B->buffer_not_empty);

return 0;

}


SGP


int take (int *item, buffer *B) {

PTHREAD_MUTEX_LOCK (&B->mutex);

while (B->count == 0)

PTHREAD_COND_WAIT (&B->buffer_not_empty, &B->mutex);

/* get data from buffer and update count and first */

PTHREAD_MUTEX_UNLOCK (&B->mutex);

PTHREAD_COND_SIGNAL (&B->buffer_not_full);

return 0;

}


SGP


protected objects (enkel in Ada)

wat: gestructureerde manier voor het programmeren van code-segmenten met garantie voor uitvoering onder

wederzijdse uitsluiting conditionele synchronisatie

hoe analoog aan monitors (genoemd protected type) voor

wederzijdse uitsluiting maar meerdere lezers enkelvoudige schrijvers mogelijk

analoog aan conditionele kritische secties (gebruik van barriers (guard) bij entries) voor conditionele synchronisatie

entry is analoog aan procedure, maar kan slechts uitgevoerd worden indien aan de barrier voldaan is

oproepen van entry zoals van een procedure

SGP


protected objects

een protected body heeft een specificatie een body

kunnen voorzien worden in de specificatie entries: dit zijn procedures die voorzien zijn van een conditie

voorwaarde voor uitvoeren: niemand voert het protected object uit en de conditie is waar

procedures: zijn niet voorzien van een conditie voorwaarde voor uitvoeren: niemand voert het protected object uit

functies: zijn niet voorzien van een conditie voorwaarde voor uitvoeren: niemand of alleen andere functies

voeren protected object uit (dit implementeert meerdere lezers)

SGP


protected object: voorbeeld 1

protected type Shared_Integer (Initial_Value: Integer) is

function read return Integer;

procedure Write (New_Value: Integer);

procedure Increment (By: Integer);

private

The_Data : Integer := Initial_Value;

end Shared_Integer;

My_Data: Shared_Integer(42);

SGP


protected object: voorbeeld 1protected body Shared_Integer is

function Read return Integer isbegin

return The_Data; end Read;procedure Write (New_Value: Integer) isbegin

The_Data := New_Value; end Write;procedure Increment (By: Integer) isbegin

The_Data := The_Data + By; end Increment;

end Shared_Integer;

SGP



Buffer_Size : constant Integer := 10;type Index is mod Buffer_Size;subtype Count is Natural range 0 .. Buffer_Size;type Buffer is array (Index) of Data_Item;

protected type Bounded_Buffer isentry Get (Item: out Data_Item);entry Put (Item: in Data_Item);

privateFirst : Index := Index’First;Last : Index := Index’Last;Number_In_Buffer : Count := 0;Buf : Buffer;

end Bounded_Buffer;

My_Buffer: Bounded_Buffer;

SGP



protected body Bounded_Buffer isentry Get (Item: out Data_Item)

when Number_In_Buffer > 0 isbegin

Item := Buf(First);First := First + 1;Number_In_Buffer := Number_In_Buffer - 1;

end Get;entry Put (Item: in Data_Item)

when Number_In_Buffer < Buffer_Size isbegin

Last := Last + 1;Buf(Last) := Item;Number_In_Buffer := Number_In_Buffer + 1;

end Put;end Bounded_Buffer;

SGP


protected object: voorbeeld 3protected Resource_Control is

entry Allocate;procedure Deallocate;

privateFree : Boolean := True;end Resource_Control;

protected body Resource_Control isentry Allocate when Free isbegin

Free := False;end Allocate;procedure Deallocate isbegin

Free := True;end Deallocate;

end Resource_Control ;

SGP



een taak wil een boodschap sturen naar andere taken die hierop wachten

indien er geen wachtende taken zijn wordt er geen boodschap achtergelaten

protected type Broadcast is

entry Receive (M: out Message);

procedure Send (M: Message);

private

New_Message : Message;

Message_Arrived : Boolean := False;

end Broadcast ;

SGP


protected object: voorbeeld 4protected body Broadcast is

entry Receive (M: out Message) when Message_Arrived isbegin

M := New_Message;if Receive’Count = 0 then Message_Arrived := False;end if;

end Receive;procedure Send (M: Message) isbegin

if Receive’Count > 0 then Message_Arrived := True;New_Message := M;

end if;end Send;

end Broadcast ;

SGP



pakket dat semaforen aanbiedt, geïmplementeerd met behulp van een protected object

package Semaphore_Package istype Semaphore (Initial : Natural := 1) is limited private;procedure Wait (S: in out Semaphore);procedure Signal (S: in out Semaphore);

privateprotected type Semaphore (Initial : Natural := 1) is

entry Wait_Imp;procedure Signal_Imp;

privateValue: Natural := Initial;

end Semaphore ;end Semaphore_Package ;

SGP


protected object: voorbeeld 5package body Semaphore_Package is

protected body Semaphore is

entry Wait_Imp when Value > 0 is

begin Value := Value - 1;

end Wait_Imp;

procedure Signal_Imp is

begin Value := Value + 1;

end Signal_Imp;

end Semaphore;

end Semaphore_Package ;

procedure Wait (S: in out Semaphore);

begin S.Wait_Imp

end Wait;

procedure Signal (S: in out Semaphore);

begin S.Signal_Imp

end Signal;

end Semaphore_Package ;




synchronisatie en communicatie met behulp van boodschappen

SGP


overzicht

boodschappen-systemen variëren volgens synchronisatiemodel procesbenoeming structuur van boodschappen

het boodschappenmodel in Ada rendez-vous selectief wachten

boodschappen in POSIX

SGP


synchronisatiemodel

impliciete synchronisatie

ontvanger kan niets ontvangen voordat zender iets stuurt

bij communicatie via gedeeld geheugen is dat niet zo

lezer weet niet wanneer schrijver iets geschreven heeft

hier is expliciete synchronisatie nodig

verschillende semantieken mogelijk voor ontvangen

blokkerend als geen boodschap klaar staat (meest voorkomend)

niet blokkerend als er geen boodschap klaar staat

(of wordt niet aangeboden, of enkel als speciaal geval)

SGP


synchronisatiemodel

verschillende semantieken mogelijk voor zenden asynchroon

zend keert terug direct nadat opdracht geregistreerd is zend keert terug nadat opdracht geregistreerd is en de inhoud van

de boodschap gekopieerd is naar een interne buffer in het systeem (komt meest voor bij asynchroon)

zend keert terug na boodschap ontvangen is op andere machine synchroon (rendez-vous)

zend keert terug nadat de boodschap ontvangen is door het ontvangend proces

zend keert terug nadat de boodschap verwerkt is door het ontvangend proces

niet-locale invocatie (wordt door sommigen ook synchroon genoemd) zend keer terug met het antwoord van de ontvanger

SGP


synchronisatiemodel zowel een synchrone als een asynchrone boodschap kan een

antwoord verwachten: bij niet-locale invocatie is het antwoord beschikbaar bij het

terugkeren van het verzendingsprimitief bij asynchrone communicatie kan men extra primitieven

voorzien waarbij men kan testen (en eventueel blokkeren) op de aankomst van een antwoord

synchrone communicatie is gemakkelijker te programmeren dan asynchrone

asynchrone is soms noodzakelijk (denk aan dienstverleners) asynchrone werking wordt soms bekomen door voor een (serie

van) boodschap-versturen/antwoord-ontvangen combinatie een aparte controledraad op te starten dat onafhankelijk van andere controledraden kan uitvoeren

SGP


synchronisatiemodel

vergelijking

asynchrone communicatie: versturen van een brief met de post

(of met email)

synchrone communicatie: telefoneren

SGP


synchronisatiemodel

gebruik van asynchrone communicatie om synchrone communicatie na te bootsend

P1 P2

asyn_send (message) wait (message)

wait (acknowledgement) asyn_send (acknowledgement)

gebruik van asynchrone communicatie om niet-locale invocatie na te bootsend

P1 P2

asyn_send (message) wait (message)

wait (reply) .....

construct reply

.....

asyn_send (reply)

SGP


synchronisatiemodel

asynchrone communicatie voordelen

flexibeler (men kan er synchrone communicatie mee nabootsen, dus lijkt synchrone communicatie niet echt nodig)

nadelen veel systeembuffers zijn nodig om nog niet gelezen

boodschappen bij te houden (ideaal oneindig veel) meestal wordt een asynchrone boodschap toch

gecombineerd met een ontvangst van een ack bij synchrone communicatie nagebootst met asynchrone

primitieven zijn in totaal meer primitieven nodig: programma wordt complexer

moeilijk om correctheid van een volledig systeem te bewijzen

SGP


synchronisatiemodel

gebruik van synchrone communicatie om asynchrone

communicatie na te bootsend dit is ook mogelijk

vraagt het creëren van bufferprocessen

kan kostelijk zijn

SGP


procesbenoeming

directe benoeming proces dat zendt bepaalt naar welk proces gezonden wordt gebruikt hiervoor een of andere procesidentificatie

indirecte benoeming proces dat zendt bepaalt een tussenliggende entiteit

(poort, kanaal, mailbox) is algemener dan procesidentificatie

een proces kan ontvangen van meerdere mailboxen (zonder dat de zender daarvan bewust is)

een mailbox kan verhuizen van proces zonder dat zender dat hoeft te merken

een mailbox is een soort interface naar een deel van een programma

send <message> to <proces-name>

send <message> to <mailbox>

SGP


procesbenoeming symmetrische benoeming

ontvangend proces aangeeft van wie/wat ze een boodschap wenst te ontvangen

asymmetrische benoeming ontvangend proces wenst te ontvangen van om het even

wie/wat

send <message> to <proces-name>

wait <message> from <proces-name>

wait <message>

SGP


procesbenoeming

verdere mogelijkheden bij indirecte benoeming meerdere-naar-één verzendingsmodel

past goed bij cliënt/server model

kan eigenlijk ook bij directe benoeming

één-naar-meerdere verzendingsmodel

multicast en broadcast

interessant wanneer meerdere servers gelijke diensten

aanbieden

meerdere-naar-meerdere verzendingsmodel

meerdere cliënten en meerdere servers

SGP


structuur van boodschappen

veel variatie soms mogen pointers niet doorgegeven worden (die

hebben uiteindelijk maar zin binnen een adresruimte) maar dit wordt momenteel meer en meer opgelost door een

tussenliggende laag (zie Remote Procedure Call)

altijd nodig: conversie van gegevens naar de voorstelling van het

ontvangend proces (en dus de ontvangende machine) getallen (integers, reals enz. worden niet op dezelfde manier

voorgesteld) little-endian (2143) en big-endian (1234) architecturen

1 2 3 4

SGP


het boodschappenmodel in Ada

belangrijkste characteristieken synchronisatiemodel: niet-locale invocatie procesbenoeming: direct, asymmetrisch structuur van boodschappen: vrij, zoals parameters

terminologie boodschap ontvangen

declaratie via entry ontvangen via accept

boodschap versturen geen nieuwe term of constructie analoog aan het oproepen van een procedure of een

protected entry

SGP



Task Time_Server is

entry Read_Time (Now: out Time);

entry Set_Time (New_Time: Time);

end Time_Server ;

declaratie van ontvangst van boodschap: entry parameters = inhoud van boodschappen (aanvraag en antwoord)

Time_Server.Read_Time(T)

-- met T van type Time

zenden van een boodschap = oproepen van een taak = vragen om een rendez-vous (dit is blokkerend)

opgeroepen taak wordt benoemd: directe benoeming oproepende taak zal wachten op resultaat: niet-locale invocatie

SGP



accept Read_Time (Now: out Time) do

Now := Clock;

end Read_Time;

ontvangen van een boodschap = aanvaarden van een rendez-vous (dit is blokkerend)

accept-bevel moet in body van taak voorkomen (niet in opgeroepen procedure) mag om het even waar in body van taak staan (bv midden in lus)

accept geeft niet aan met wie men een rendez-vous aanvaardt: benoeming is dus asymmetrisch

antwoord vertrekt bij het einde van accept-blok (invocatie)

procedure Test;

N: constant Integer := 1000;

Task T1 is

entry Exchange (I: Integer; J: out Integer)

end T1;

Task body T1 is

A, B: Integer;

begin

for K in 1 .. N loop

-- produce A

accept Exchange (I: Integer; J: out Integer) do

J := A; B := I;

end Exchange;

-- consume B

end loop;

end T1;

rendez-vous: voorbeeld

Task body T2 is

C, D: Integer;

begin

for K in 1 .. N loop

-- produce C

T1.Exchange (C, D);

-- consume D

end loop;

end T2;

begin

null;

end Test;

SGP


uitzonderingen tijdens rendez-vous

opvangen van uitzondering in blok van de accept-code uitzondering wordt opgevangen: geen probleem

uitzondering wordt niet opgevangen:

accept eindigt onmiddellijk

de uitzondering propageert

in de omsluitende blok van de accept-code

in het blok van de zender

-- bij ontvanger (server)

task File_Handler is

entry Open (F: File_Type);

.....

end File_Handler ;

Task body File_Handler is

.....

begin

-- zie rechts

end File_Handler ;

-- bij zender (client)

begin

File_Handler.Open(File);

exception when File_Not_Exist

=> File_Handler.Create(File); File_Handler.Open(File);

end;

loop

begin

.....

accept Open(F: File_Type) do

loop

begin

Device_Open(F); return;

exception when Off_Line

=> Boot_Device;

end;

end loop;

end Open;

....

exception when File_Not_Exist

=> null; end;end loop;

rendez-vous en exceptions: vb

SGP


selectief wachten

situatie: ontvanger wenst te wachten op een boodschap uit een groep van mogelijkheden elke mogelijkheid kan voorafgegaan worden door wachter-test wanneer meerdere mogelijkheden open zijn (hetzij omdat de

wachter-test true is, hetzij omdat er geen wachter test is) run-time systeem kiest één uit op niet-deterministisch manier vgl: if x <= y then m := x elseif x >= y then m := y

(dit is wel deterministisch)

SGP


selectief wachten constructie in Ada:

sleutelwoord select (te vergelijken met een case) 4 mogelijkheden:

accept else-alternatief

wordt gekozen alleen indien geen enkel ander alternatief onmiddellijk uitvoerbaar is

delay-alternatief hierbij wordt een tijdje gewacht (zie hoofdstuk 12)

terminatewordt gekozen alleen indien geen enkele andere taak nog

een rendez-vous kan doen in dat geval wordt de taak van de select geëindigd

selectief wachten: voorbeeldtask Telephone_Operator is

entry Directory_Enq (P : in Name; Num: out Number);entry Report_Fault (Num: Number);

privateentry Allocate_Repair_Worker (Num: out Number);

end Telephone_Operator ;Task body Telephone_Operator is

Workers : constant Integer := 10;Failed : Number;task type Repair_Worker;Work_Force : array (1 .. Workers) of Repair_Workers;task body Repair_Worker is .....;.....

begin-- zie volgende slide

end Telephone_Operator ;

loop -- prepare to accept next requestselect

accept Directory_Enq (P : in Name; Num: out Number) do ..... end Directory_Enquiry;

oraccept Report_Fault (Num: Number) do .....end Report_Fault;-- change Unallocated_Faults

orwhen Unallocated_Faults => accept Allocate_Repair_Worker (Num: out Number) do ..... end Allocate_Repair_Worker ;

orterminate;

end select;end loop;

selectief wachten: voorbeeld

SGP


boodschappenmodel bij POSIX

belangrijkste characteristieken synchronisatiemodel: asynchroon procesbenoeming: indirect, symmetrisch structuur van boodschappen: vrij

terminologie boodschap wordt verstuurd en ontvangen van message queue

kan vele lezers en vele schrijvers hebben bij de creatie kan men o.a. ook opgeven: lengte queue,

maximale grootte van een individuele boodschap, protectie in het normaal geval zal een proces wachten als de

message queue vol is (bij zenden) of leeg is (bij ontvangen) proces kan ook verwittigd worden van boodschap via signal

SGP



een queue krijgt een naam bij creatie (analoog aan bestandsnaam)

een queue heeft vele attributen (zoals lengte queue, maximale grootte van individuele boodschap, protectie

mqd_t mq_open (const char *mq_name, int oflags, mode_t mode,

struct mq_attr *mq_attr);

/* open/create the named message queue */

int mq_setattr (mqd_t mq, const struct mq_attr *new_attrs,

struct mq_attr *old_attrs);

/* set the current attributes associated with mq */

int mq_close (mqd_t mq);

int mq_unlink (const char *mq_name);

SGP



zenden en ontvangen van boodschappen

ssize_t mq_receive (mad_t mq, char *msq_buffer,

size_t buflen, unsigned int *msgprio);

/* get the next message in the queue and store it in the

area pointed at by msq_buffer;

the actual size of the message is returned */

int mq_send (mqd_t mq, const char *msq,

size_t msglen, unsigned int msgprio);

/* send the message pointed at by msq */

SGP


resultaat bevraging te uitgebreid

want niet interessant

want overlapt

OK mag meer

inleiding algemeen stuk, voorbeelden 1 2 26

inleiding alg. stuk, karakteristieken 2 27

inleiding alg. stuk, vb van ariane 5 1 1 21 6

achtergrond Ada met voor en nadelen 2 26

Java voor embedded systems 1 2 11 15

Ada crash course: prog. in the small 18 11

Ada crash course: prog. in the large 15 14

con. prog.: multi-tasking problematiek 13 17 1

concurrent prog.: multi-tasking: POSIX 8 1 20 1

concurrent prog.: multi-tasking: Ada 26 4

SGP


resultaat bevraging

te uitgebreid

want niet interessant

want overlapt

OK mag meer

conc. prog.: shared mem: problematiek

8 22 1

conc. prog.: shared mem: POSIX 7 1 21

conc. prog.: shared mem: Ada 26 4

conc prog.: boodsch: problematiek 7 20 4

conc. prog.: boodsch: POSIX 7 2 21

conc. prog.: boodsch: Ada 26 4

Systeem-ge ï ntegreerde Programmatuur

Documents

Transcript of Systeem-ge ï ntegreerde Programmatuur