slide 1Systeem-geïntegreerde programmatuurYolande Berbers SGP Systeem-geïntegreerde Programmatuur Marc Gobin (&Yolande Berbers) Departement Computerwetenschappen (200A 03.20)

SGP slide 2Systeem-geïntegreerde programmatuurYolande Berbers practische organisatie n Marc Gobin is ziek u ik geef enkele weken les l zeker 2, waarschijnlijk 3, misschien meer u slides kun je vinden via mijn home-page l n lessen over device drivers u die geef ik al altijd n practica: zie verder

SGP slide 3Systeem-geïntegreerde programmatuurYolande Berbers overzicht van de cursus n karakteristieken van real-time systemen n Ada en Java voor real-time en embedded systemen n gelijktijdige processen n het invoeren van tijd n interrupts n device drivers n petri-netten n schedulability n temporele logica

SGP slide 4Systeem-geïntegreerde programmatuurYolande Berbers practica n 2 practica u practicum 1 l individueel l schrijven van een programma dat gebruik maakt van gelijktijdige taken l begroot op 10 uur u practicum 2 l in groepjes van 2 l schrijven van pakket voor communicatie tussen 2 pc’s l begroot op 20 uur u er wordt een demo van de 2 practica georganiseerd u timing is afhankelijk van verloop herstel Marc Gobin

slide 5Systeem-geïntegreerde programmatuurYolande Berbers SGP Systeem-geïntegreerde Programmatuur deel 3 concurrent programming: tasks

SGP slide 6Systeem-geïntegreerde programmatuurYolande Berbers concurrent programming: inleiding n concurrent programming = notaties en technieken voor u uitdrukken van potentieel parallellisme u oplossen van synchronisatie en communicatie n concurrent programming biedt u abstractiemechanismen om parallellisme te beschrijven u onafhankelijk van de implementatiedetails n de implementatie van parallellisme u onderwerp van computersystemen (hardware en software) u is onafhankelijk van concurrent programming

SGP slide 7Systeem-geïntegreerde programmatuurYolande Berbers proces, controledraad n sequentiële programmeertalen: Pascal, C, Fortran, COBOL u programma’s hebben slechts 1 controledraad (Engels: thread) u ze voeren uit, bevel per bevel, totdat het programma eindigt u het pad door het programma kan variëren al naar gelang de invoer, maar bij gelijke invoer heb je een gelijk pad n ‘concurrent’ programmeertalen (programmeertalen voor gelijklopende onderdelen) bevatten de notie van proces u elke proces heeft (tenminste) 1 controledraad u implementatie van processen: l uitvoering op 1 enkele processor (multiprogrammatie) l uitvoering op multiprocessor (met gedeeld geheugen) l uitvoering op multicomputer (met gescheiden geheugen) u concurrent slaat op potentieel parallellisme

SGP slide 8Systeem-geïntegreerde programmatuurYolande Berbers levencyclus van een proces niet bestaanduitvoerbaarbeëindigdgecreëerdinitialiserend

SGP slide 9Systeem-geïntegreerde programmatuurYolande Berbers proces, controledraad n RTSS (run-time support system) u heeft de taak van het creëren en initialiseren van een proces u eventueel ook van het schedulen van de verschillende controledraden u wordt meestal door de compiler gegenereerd n alternatief voor concurrent programmeertalen u gescheiden processen schrijven met een sequentiële taal u de mogelijkheden van het besturingssysteem gebruiken om gelijktijdige uitvoering te bekomen

SGP slide 10Systeem-geïntegreerde programmatuurYolande Berbers proces, controledraad n processen u worden voorzien in alle besturingssystemen u elke proces voert uit in een eigen virtuele machine, zonder interferentie van andere processen (logisch gezien alsof ze het enige proces zijn) n controledraden (threads) u soort subproces binnen een klassiek proces u alle controledraden hebben toegang tot gehele virtuele machine u de programmeur en de taal moeten de controledraden voor elkaar beschermen n discussie: op welk niveau moet concurrency aangeboden worden: door de taal of door het besturingssysteem ? u Ada en Java bieden concurrency in de taal u C en C++ niet

SGP slide 11Systeem-geïntegreerde programmatuurYolande Berbers proces, controledraad n voordelen van concurrent programmeertalen u beter leesbare en onderhoudbare code u draagbaarder over meerdere besturingssystemen heen u soms is er geen besturingssysteem op een real-time systeem u de compiler kan op een aantal zaken testen n voordelen combinatie sequentiële taal + besturingssyst u gemakkelijker om programma's geschreven in verschillende talen te combineren u op sommige besturingssystemen is het moeilijk om sommige concurrent taalmodellen te implementeren u omdat er standaarden zijn voor besturingssystemen, zijn de programma's draagbaarder

SGP slide 12Systeem-geïntegreerde programmatuurYolande Berbers constructies voor concurrent programmeren n 3 fundamentele faciliteiten u uitdrukken van gelijktijdig uitvoeren (door de notie van proces) u synchronisatie tussen processen u communicatie tussen processen n 3 verschillende soorten relaties u onafhankelijk u samenwerkend u in competitie

SGP slide 13Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdig uitvoeren n verschillen tussen procesmodellen u structuur u niveau u granulariteit u initialisatie u beëindiging u relaties tussen gecreëerd proces en andere u voorstelling

SGP slide 14Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdig uitvoeren n structuur u statisch l aantal processen is vast l dit aantal is gekend tijdens compilatie u dynamisch l aantal processen kan variëren van uitvoering tot uitvoering n niveau u vlak l processen enkel gedefinieerd op hoogste niveau u genest l processen kunnen een hiërarchie vormen: processen kunnen andere processen starten (vader/kind)

SGP slide 15Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdig uitvoeren n granulariteit u fijn l het is ‘goedkoop’ om processen te creëren l in een typisch programma worden er veel gecreëerd voor telkens een hele kleine taak u grof l het is ‘duur’ om een proces te creëren l er worden geen grote aantallen processen gecreëerd n initialisatie u parameters doorgeven u expliciete communicatie na creatie

SGP slide 16Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdig uitvoeren n beëindiging u beëindigen van de code u door uitvoering van een specifiek ‘zelfmoord’ bevel u expliciete moord door een ander proces u uitvoering van een niet-opgevangen uitzondering u nooit (oneindige lus) u wanneer niet meer nodig (geen communicatie meer mogelijk) n relatie tussen gecreëerd proces en andere u vader/kind: vader (creërend proces) wacht tot het kind gecreëerd en geïnitialiseerd is u hoeder/afhankelijke: hoeder kan niet het blok verlaten waarin de afhankelijke is gecreëerd, voordat de afhankelijke beëindigd is u vader en hoeder kunnen maar hoeven niet zelfde proces te zijn

SGP slide 17Systeem-geïntegreerde programmatuurYolande Berbers levencyclus van een proces wacht op init kind niet bestaand uitvoerbaar beëindigd gecreëerd initialiserend wacht op afhank. einde

SGP slide 18Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdig uitvoeren n terminologie bij object-georiënteerde systemen u elke proces is een object (maar niet omgekeerd) u actieve objecten: nemen spontaan acties u reactieve objecten l reageren enkel op invocaties (= operaties die uitgevoerd worden op een object) l bv resources (hulpmiddelen) l passieve objecten s reactieve objecten waarvan de operaties altijd kunnen uitgevoerd worden u beschermde resource: resource beschermd door een passieve entiteit u server: resource waarbij de controle actief is (proces is nodig)

SGP slide 19Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdig uitvoeren n voorstelling: 4 basis mechanismen u co-routines u fork/join u cobegin/coend u expliciete procesdeclaratie

SGP slide 20Systeem-geïntegreerde programmatuurYolande Berbers procesvoorstelling: co-routines n controle wordt expliciet doorgegeven (sleutelwoord resume): er is geen return-bevel n relatie is symmetrisch n een routine A voert ‘resume B’ uit u routine A stopt uitvoeren u routine B voert uit vanaf het punt waar het vroeger gestopt was u routine A bewaart alle statusinformatie, zodat het later op hetzelfde punt kan verder gezet worden

SGP slide 21Systeem-geïntegreerde programmatuurYolande Berbers procesvoorstelling: co-routines Co-routine ACo-routine BCo-routine C resume B resume C resume A resume B

SGP slide 22Systeem-geïntegreerde programmatuurYolande Berbers procesvoorstelling: fork en join n methode: u C := fork Feen nieuw proces start de uitvoering van F oproepend proces gaat ook verder u join C;oproepend proces wacht op einde F n gebruikt in POSIX u bij fork kun je parameters doorgeven u met wait wacht je, 1 waarde keert terug u flexibel maar niet erg gestructureerd l geven gemakkelijk aanleiding tot fouten l hoeder moet bijvoorbeeld expliciet wachten op al zijn kinderen

SGP slide 23Systeem-geïntegreerde programmatuurYolande Berbers procesvoorstelling: fork en join tijdsas fork join PFPF vaderproces voert join uit voordat kind beëindigd is kindproces heeft gedaan voordat vader join uitvoert

SGP slide 24Systeem-geïntegreerde programmatuurYolande Berbers procesvoorstelling: cobegin/coend n na cobegin (of parbegin) staan een aantal blokken die in parallel uitgevoerd worden (ze worden allemaal samen opgestart) n het vaderproces wacht, of voert 1 van de blokken uit n bij coend (of parend) wordt er gewacht tot alle blokken beëindigd zijn

SGP slide 25Systeem-geïntegreerde programmatuurYolande Berbers procesvoorstelling: cobegin/coend tijdsas coend cobegin

SGP slide 26Systeem-geïntegreerde programmatuurYolande Berbers procesvoorstelling: ex-/impliciete procesdeclaratie n expliciete procesdeclaratie u routines geven tekstueel aan of ze door een apart proces uitgevoerd worden (modula 1) u het is niet meer de oproeper van de routine die aangeeft dat een nieuw proces gecreëerd moet worden n impliciete procesdeclaratie u alle processen die gedeclareerd worden binnen een blok beginnen in parallel uit te voeren bij begin van het blok (Ada)

SGP slide 27Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in Ada n benaming voor sequentieel proces: task u kan gedeclareerd worden u wordt gecreëerd wanneer declaratie zichtbaar wordt: impliciet u procedure eenvoudige_taak eindigt niet voordat task A eindigt procedure eenvoudige_taak is task A; task body A is -- lokale declaraties begin -- bevelen van de taak A end A; begin...-- taak A begint met uitvoeren voor het eerste bevel in dit blok end eenvoudige_taak;

SGP slide 28Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in Ada n het is mogelijk een task-type te definiëren n 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 slide 29Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in Ada n parameters kunnen doorgegeven worden bij initialisatie procedure Main is type Dimension is (Xplane, Yplane); task type Control (Dim: Dimension); C1: Control(Xplane); C2: Control(Yplane); task body Control is -- lokale declaraties begin -- bevelen van de taak Control (zie in boek) end Control; begin null; end Main;

SGP slide 30Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in Ada n uitzonderingen u bij initialisatie: de creërende taak krijgt de uitzondering ‘Tasking_error’ u tijdens uitvoering: l de nieuwe taak mag de uitzonderingen opvangen l niet opgevangen uitzondering: nieuwe taak wordt beëindigd n beëindiging van een taak u de taak beëindigt zijn uitvoering (normaal of door uitzondering) u de taak voert het bevel ‘terminate’ uit (zie later) u de taak is gestopt door een andere taak (via abort)

SGP slide 31Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in POSIX n twee mechanismen u voor processen l fork() creëert een exacte copie van het oproepende proces l met wait() kan het oproepende proces wachten op het gecreëerde u voor threads l allerhande routines voor creatie en beheer van threads l vaak met veel parameters l nogal complex n beide mechanismen situeren zich op het niveau van het besturingssysteem (zijn dus niet in een taal geïntegreerd)

SGP slide 32Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in POSIX n threads in POSIX u alle threads hebben attributen (vb stack size) l 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 slide 33Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in POSIX n threads in POSIX u alle threads hebben een identifier, uniek in het proces l 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 slide 34Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in POSIX n threads in POSIX u thread is klaar om uit te voeren na creatie l 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 slide 35Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in POSIX n threads in POSIX u thread kan eindigen l door oproep van pthread_exit l bij ontvangst van een signal (zie hoofdstuk 10) l 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 slide 36Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in POSIX n threads in POSIX u 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 slide 37Systeem-geïntegreerde programmatuurYolande Berbers gelijktijdige uitvoering in POSIX n threads in POSIX u opkuisen na uitvoering en vrijgave van geheugen: l bij join l 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 slide 38Systeem-geïntegreerde programmatuurYolande Berbers een eenvoudig real-time systeem n aflezen van temperatuur en aanpassen van verwarming n aflezen van druk en aanpassen van pomp n telkens de waarden ook op het scherm printen P T S thermokoppel verwarming drukmeter pomp scherm

SGP slide 39Systeem-geïntegreerde programmatuurYolande Berbers een eenvoudig real-time systeem n 3 implementatiemethoden u 1 sequentieel programma l houdt geen rekening met het feit dat T, P en S logisch gezien gelijktijdig en onafhankelijk van elkaar zijn l vraagt geen ondersteuning van het run-time- of besturingssysteem u 3 sequentiële programma's l T, P en S zijn geschreven in een sequentiële taal l met primitieven van het besturingssysteem worden 3 processen hiervoor gecreëerd u 1 concurrent programma l T, P en S zijn 3 threads l run-time ondersteuning is nodig

SGP slide 40Systeem-geïntegreerde programmatuurYolande Berbers een eenvoudig real-time systeem u 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 slide 41Systeem-geïntegreerde programmatuurYolande Berbers een eenvoudig real-time systeem n 1 sequentieel programma: bespreking u temperatuurmetingen en drukmetingen gebeuren met gelijke intervallen (misschien hoeft dat niet in de praktijk) l mogelijke oplossing: een aantal if-then-else bevelen toevoegen u wanneer het programma bezig is met temperatuur kan er geen aandacht gegeven worden aan de druk en vice-versa u als probleem met lezen van 1 van de 2 metingen blokkeert het geheel (dus ook het deel dat daar niets mee te maken heeft) l mogelijke oplossing: testen of er kan gelezen worden (p. 195) s nadeel is hier wel dat men test via ‘polling’ (busy waiting) s dit vraagt veel processortijd u belangrijkste opmerking: geen weerspiegeling van werkelijkheid, waar temperatuur en druk volledig onafhankelijke subsystemen zijn

SGP slide 42Systeem-geïntegreerde programmatuurYolande Berbers een eenvoudig real-time systeem u 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 slide 43Systeem-geïntegreerde programmatuurYolande Berbers een eenvoudig real-time systeem u 3 sequentiële programma's (met primitieven van het besturingssysteem worden 3 processen hiervoor gecreëerd) procedure Controller is TC, PS: Thread_Id; begin TC := Create_Thread (Temp_Controller’Access); PC := Create_Thread (Pressure_Controller’Access); end Controller; n bespreking u doordat de taal geen ondersteuning biedt is dit moeilijk te schrijven en te onderhouden (zeker voor grotere systemen) u bv niet erg duidelijk uit de code welke procedures nu gewone zijn en welke bedoeld zijn om als proces uit te voeren

SGP slide 44Systeem-geïntegreerde programmatuurYolande Berbers een eenvoudig real-time systeem u 1 concurrent programma waarbij T, P en S 3 threads zijn procedure Controller is task Pressure_Controller; task Temp_Controller; task body Temp_Controller is beginloop 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 slide 45Systeem-geïntegreerde programmatuurYolande Berbers een eenvoudig real-time systeem n 1 concurrent programma: bespreking u de logica van de toepassing is mooi zichtbaar in de code u dit maakt het geheel leesbaar en onderhoudbaar n probleem dat telkens genegeerd werd: synchronisatie van de data die naar het scherm gestuurd worden (zie hoofdstuk 8)

slide 46Systeem-geïntegreerde programmatuurYolande Berbers SGP Systeem-geïntegreerde Programmatuur deel 3 concurrent programming: synchronisatie en communicatie met gedeelde variabelen

SGP slide 47Systeem-geïntegreerde programmatuurYolande Berbers overzicht n probleemstelling: kritische sectie en conditionele synchronisatie u vb kritische sectie: verhogen van een gedeelde variabele met 1 u vb conditionele synchronisatie: producent/consument met buffer u verondersteld gekend n oplossing 1: busy waiting, suspend/resume: kort n oplossing 2: semaforen n oplossing 3: conditionele kritische secties n oplossing 4: monitors n protected objects: oplossing van Ada

SGP slide 48Systeem-geïntegreerde programmatuurYolande Berbers ondersteuning voor semaforen n Ada u geen directe ondersteuning in de taal u gemakkelijk om een package te maken die het aanbiedt voor gebruik tussen taken u 8.4.5: klassiek voorbeeld van producer/consumer in Ada n C u geen ondersteuning n POSIX u tellende semaforen tussen aparte processen en voor verschillende threads in een proces

SGP slide 49Systeem-geïntegreerde programmatuurYolande Berbers n standard operations for counting semaphores u 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 slide 50Systeem-geïntegreerde programmatuurYolande Berbers 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 n non-standard operations for counting sem. u non-blocking wait, determining value of sem.

SGP slide 51Systeem-geïntegreerde programmatuurYolande Berbers nadelen van semaforen n semaforen leiden gemakkelijk tot fouten (en zijn dus ongeschikt in real-time programmatuur) u vergeet er 1 en het programma loopt fout u heel moeilijk om te vinden waar precies wait of signal vergeten u deadlock kan gemakkelijk optreden (misschien maar in heel weinig voorkomende gevallen, maar dat is juist moeilijk te testen)

SGP slide 52Systeem-geïntegreerde programmatuurYolande Berbers monitors n wat u gestructureerde manier om code-segmenten te schrijven met garantie voor uitvoering onder wederzijdse uitsluiting, en met mogelijkheid tot conditionele synchronisatie n hoe u module met een verzameling van kritische secties die elk als procedure of functie geschreven zijn u module heet monitor u alle variabelen die beschermd moeten worden zijn verborgen (information hiding) u conditie variabelen voor conditionele synchronisatie l wait: blokkeert altijd het uitvoerende proces l signal: deblokkeert een wachtend proces indien er zo één is

SGP slide 53Systeem-geïntegreerde programmatuurYolande Berbers monitor: voorbeeld monitor 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 slide 54Systeem-geïntegreerde programmatuurYolande Berbers 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 slide 55Systeem-geïntegreerde programmatuurYolande Berbers monitors (commentaar bij voorbeeld) n minstens 2 processen zijn betrokken u één producent (maar het kunnen er meerdere zijn) u één consument (maar het kunnen er meerdere zijn) n processen kunnen geblokkeerd zijn u omdat ze de monitor proberen binnen te gaan l ze proberen append of take uit te voeren u omdat ze wachten op een conditie l er is bv geen plaats in de buffer l of er zijn geen elementen in de buffer n er is dus een mogelijke wachtrij u voor de monitor zelf u en voor elke conditievariabele

SGP slide 56Systeem-geïntegreerde programmatuurYolande Berbers monitors n welk proces mag (exclusief) uitvoeren na een signal ? u proces dat signal uitvoert (proces dat een wait deed wacht nog even) u proces dat een wait deed (proces dat de signal doet moet nu wachten) n mogelijke semantiek voor signal u signal mag alleen als laatse instructie voor verlaten van monitor l zoals in het producer/consumer voorbeeld l niet erg flexibel u signal heeft als neven-effect een return (dus het uitvoerend proces wordt verplicht de monitor te verlaten) u proces dat signal uitvoert blijft uitvoeren; proces dat gedeblokkeerd is moet daarna weer vechten om de monitor te mogen betreden u proces dat de signal uitvoert blokkeert, en proces dat gedeblokkeerd werd mag direct uitvoeren

SGP slide 57Systeem-geïntegreerde programmatuurYolande Berbers monitors n voordeel van monitors u gestructureerde manier voor het programmeren van wederzijdse uitsluiting n nadeel van monitors u laag-niveau manier voor het programmeren van conditionele synchronisatie

SGP slide 58Systeem-geïntegreerde programmatuurYolande Berbers mutexes and condition variables in POSIX n each monitor has an associated (initialized) mutex variable n all operations on the monitor are surrounded by calls to lock and unlock of the mutes n condition synchronization is provided by associating condition variables with the mutex n when a thread waits on a condition variable, its lock on the associated mutex is released n when a thread successfully returns from the conditional wait, it again holds the lock

SGP slide 59Systeem-geïntegreerde programmatuurYolande Berbers 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 */ mutexes and condition variables in POSIX

SGP slide 60Systeem-geïntegreerde programmatuurYolande Berbers 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 /* mutexes and condition variables in POSIX

SGP slide 61Systeem-geïntegreerde programmatuurYolande Berbers 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 */ mutexes and condition variables in POSIX

SGP slide 62Systeem-geïntegreerde programmatuurYolande Berbers n example: bounded buffer consisting of u mutex u two condition vairables (buffer_not_full and buffer_not_empty) u a count of number of elements u the buffer itself u the positions of first and last items in buffer u routine ‘append’ u routine ‘take’ mutexes and condition variables in POSIX

SGP slide 63Systeem-geïntegreerde programmatuurYolande Berbers #define SYS_CALL (A) if (sys_call(A) != 0) error() /* where error is function which undertakes some error processing */ n note: lighter notation for calls in POSIX u error conditions from POSIX: return -1 u for reliability: every call to system function should test the return value u in book: macro mutexes and condition variables in POSIX

SGP slide 64Systeem-geïntegreerde programmatuurYolande Berbers # 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 */ mutexes and condition variables in POSIX

SGP slide 65Systeem-geïntegreerde programmatuurYolande Berbers 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; } mutexes and condition variables in POSIX

SGP slide 66Systeem-geïntegreerde programmatuurYolande Berbers 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; } mutexes and condition variables in POSIX

SGP slide 67Systeem-geïntegreerde programmatuurYolande Berbers protected objects (enkel in Ada) n wat: gestructureerde manier voor het programmeren van u code-segmenten met garantie voor uitvoering onder wederzijdse uitsluiting u conditionele synchronisatie n hoe u analoog aan monitors (genoemd protected type) voor wederzijdse uitsluiting l maar meerdere lezers enkelvoudige schrijvers mogelijk u analoog aan conditionele kritische secties (gebruik van barriers (guard) bij entries) voor conditionele synchronisatie l entry is analoog aan procedure, maar kan slechts uitgevoerd worden indien aan de barrier voldaan is l oproepen van entry zoals van een procedure

SGP slide 68Systeem-geïntegreerde programmatuurYolande Berbers protected objects n een protected body heeft u een specificatie u een body n kunnen voorzien worden in de specificatie u entries: dit zijn procedures die voorzien zijn van een conditie l voorwaarde voor uitvoeren: niemand voert het protected object uit en de conditie is waar u procedures: zijn niet voorzien van een conditie l voorwaarde voor uitvoeren: niemand voert het protected object uit u functies: zijn niet voorzien van een conditie l voorwaarde voor uitvoeren: niemand of alleen andere functies voeren protected object uit (dit implementeert meerdere lezers)

SGP slide 69Systeem-geïntegreerde programmatuurYolande Berbers 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 slide 70Systeem-geïntegreerde programmatuurYolande Berbers protected object: voorbeeld 1 protected body Shared_Integer is function Read return Integer is begin return The_Data; end Read; procedure Write (New_Value: Integer) is begin The_Data := New_Value; end Write; procedure Increment (By: Integer) is begin The_Data := The_Data + By; end Increment; end Shared_Integer;

SGP slide 71Systeem-geïntegreerde programmatuurYolande Berbers protected object: voorbeeld 2 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 is entry Get (Item: out Data_Item); entry Put (Item: in Data_Item); private First : Index := Index’First; Last : Index := Index’Last; Number_In_Buffer : Count := 0; Buf : Buffer; end Bounded_Buffer; My_Buffer: Bounded_Buffer;

SGP slide 72Systeem-geïntegreerde programmatuurYolande Berbers protected object: voorbeeld 2 protected body Bounded_Buffer is entry Get (Item: out Data_Item) when Number_In_Buffer > 0 is begin 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 is begin Last := Last + 1; Buf(Last) := Item; Number_In_Buffer := Number_In_Buffer + 1; end Put; end Bounded_Buffer;

SGP slide 73Systeem-geïntegreerde programmatuurYolande Berbers protected object: voorbeeld 3 protected Resource_Control is entry Allocate; procedure Deallocate; private Free : Boolean := True; end Resource_Control; protected body Resource_Control is entry Allocate when Free is begin Free := False; end Allocate; procedure Deallocate is begin Free := True; end Deallocate; end Resource_Control ;

SGP slide 74Systeem-geïntegreerde programmatuurYolande Berbers protected object: voorbeeld 4 n een taak wil een boodschap sturen naar andere taken die hierop wachten n 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 slide 75Systeem-geïntegreerde programmatuurYolande Berbers protected object: voorbeeld 4 protected body Broadcast is entry Receive (M: out Message) when Message_Arrived is begin M := New_Message; if Receive’Count = 0 then Message_Arrived := False; end if; end Receive; procedure Send (M: Message) is begin if Receive’Count > 0 then Message_Arrived := True; New_Message := M; end if; end Send; end Broadcast ;

SGP slide 76Systeem-geïntegreerde programmatuurYolande Berbers protected object: voorbeeld 5 n pakket dat semaforen aanbiedt, geïmplementeerd met behulp van een protected object package Semaphore_Package is type Semaphore (Initial : Natural := 1) is limited private; procedure Wait (S: in out Semaphore); procedure Signal (S: in out Semaphore); private protected type Semaphore (Initial : Natural := 1) is entry Wait_Imp; procedure Signal_Imp; private Value: Natural := Initial; end Semaphore ; end Semaphore_Package ;

SGP slide 77Systeem-geïntegreerde programmatuurYolande Berbers protected object: voorbeeld 5 package body Semaphore_Package is protected body Semaphore is entry Wait_Imp when Value > 0 is beginValue := Value - 1; end Wait_Imp; procedure Signal_Imp is beginValue := 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 ;

slide 78Systeem-geïntegreerde programmatuurYolande Berbers SGP Systeem-geïntegreerde Programmatuur deel 3 concurrent programming: synchronisatie en communicatie met behulp van boodschappen

SGP slide 79Systeem-geïntegreerde programmatuurYolande Berbers overzicht n boodschappen-systemen variëren volgens u synchronisatiemodel u procesbenoeming u structuur van boodschappen n het boodschappenmodel in Ada u rendez-vous u selectief wachten n boodschappen in POSIX

SGP slide 80Systeem-geïntegreerde programmatuurYolande Berbers synchronisatiemodel n impliciete synchronisatie u ontvanger kan niets ontvangen voordat zender iets stuurt u bij communicatie via gedeeld geheugen is dat niet zo l lezer weet niet wanneer schrijver iets geschreven heeft l hier is expliciete synchronisatie nodig n verschillende semantieken mogelijk voor ontvangen u blokkerend als geen boodschap klaar staat (meest voorkomend) u niet blokkerend als er geen boodschap klaar staat (of wordt niet aangeboden, of enkel als speciaal geval)

SGP slide 81Systeem-geïntegreerde programmatuurYolande Berbers synchronisatiemodel n verschillende semantieken mogelijk voor zenden u asynchroon l zend keert terug direct nadat opdracht geregistreerd is l 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) l zend keert terug na boodschap ontvangen is op andere machine u synchroon (rendez-vous) l zend keert terug nadat de boodschap ontvangen is door het ontvangend proces l zend keert terug nadat de boodschap verwerkt is door het ontvangend proces u niet-locale invocatie (wordt door sommigen ook synchroon genoemd) l zend keer terug met het antwoord van de ontvanger

SGP slide 82Systeem-geïntegreerde programmatuurYolande Berbers synchronisatiemodel n zowel een synchrone als een asynchrone boodschap kan een antwoord verwachten: u bij niet-locale invocatie is het antwoord beschikbaar bij het terugkeren van het verzendingsprimitief u bij asynchrone communicatie kan men extra primitieven voorzien waarbij men kan testen (en eventueel blokkeren) op de aankomst van een antwoord n synchrone communicatie is gemakkelijker te programmeren dan asynchrone n asynchrone is soms noodzakelijk (denk aan dienstverleners) n 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 slide 83Systeem-geïntegreerde programmatuurYolande Berbers synchronisatiemodel n vergelijking u asynchrone communicatie: versturen van een brief met de post (of met ) u synchrone communicatie: telefoneren

SGP slide 84Systeem-geïntegreerde programmatuurYolande Berbers synchronisatiemodel n gebruik van asynchrone communicatie om synchrone communicatie na te bootsend P1P2 asyn_send (message)wait (message) wait (acknowledgement)asyn_send (acknowledgement) n gebruik van asynchrone communicatie om niet-locale invocatie na te bootsend P1P2 asyn_send (message)wait (message) wait (reply)..... construct reply..... asyn_send (reply)

SGP slide 85Systeem-geïntegreerde programmatuurYolande Berbers synchronisatiemodel n asynchrone communicatie u voordelen l flexibeler (men kan er synchrone communicatie mee nabootsen, dus lijkt synchrone communicatie niet echt nodig) u nadelen l veel systeembuffers zijn nodig om nog niet gelezen boodschappen bij te houden (ideaal oneindig veel) l meestal wordt een asynchrone boodschap toch gecombineerd met een ontvangst van een ack l bij synchrone communicatie nagebootst met asynchrone primitieven zijn in totaal meer primitieven nodig: programma wordt complexer l moeilijk om correctheid van een volledig systeem te bewijzen

SGP slide 86Systeem-geïntegreerde programmatuurYolande Berbers synchronisatiemodel n gebruik van synchrone communicatie om asynchrone communicatie na te bootsend u dit is ook mogelijk u vraagt het creëren van bufferprocessen u kan kostelijk zijn

SGP slide 87Systeem-geïntegreerde programmatuurYolande Berbers procesbenoeming n directe benoeming u proces dat zendt bepaalt naar welk proces gezonden wordt u gebruikt hiervoor een of andere procesidentificatie n indirecte benoeming u proces dat zendt bepaalt een tussenliggende entiteit (poort, kanaal, mailbox) u is algemener dan procesidentificatie l een proces kan ontvangen van meerdere mailboxen (zonder dat de zender daarvan bewust is) l een mailbox kan verhuizen van proces zonder dat zender dat hoeft te merken l een mailbox is een soort interface naar een deel van een programma send to

SGP slide 88Systeem-geïntegreerde programmatuurYolande Berbers procesbenoeming n symmetrische benoeming u ontvangend proces aangeeft van wie/wat ze een boodschap wenst te ontvangen n asymmetrische benoeming u ontvangend proces wenst te ontvangen van om het even wie/wat send to wait from wait

SGP slide 89Systeem-geïntegreerde programmatuurYolande Berbers procesbenoeming n verdere mogelijkheden bij indirecte benoeming u meerdere-naar-één verzendingsmodel l past goed bij cliënt/server model l kan eigenlijk ook bij directe benoeming u één-naar-meerdere verzendingsmodel l multicast en broadcast l interessant wanneer meerdere servers gelijke diensten aanbieden u meerdere-naar-meerdere verzendingsmodel l meerdere cliënten en meerdere servers

SGP slide 90Systeem-geïntegreerde programmatuurYolande Berbers structuur van boodschappen n veel variatie n soms mogen pointers niet doorgegeven worden (die hebben uiteindelijk maar zin binnen een adresruimte) u maar dit wordt momenteel meer en meer opgelost door een tussenliggende laag (zie Remote Procedure Call) n altijd nodig: u conversie van gegevens naar de voorstelling van het ontvangend proces (en dus de ontvangende machine) u getallen (integers, reals enz. worden niet op dezelfde manier voorgesteld) u little-endian (2143) en big-endian (1234) architecturen 1 234

SGP slide 91Systeem-geïntegreerde programmatuurYolande Berbers het boodschappenmodel in Ada n belangrijkste characteristieken u synchronisatiemodel:niet-locale invocatie u procesbenoeming:direct, asymmetrisch u structuur van boodschappen:vrij, zoals parameters n terminologie u boodschap ontvangen l declaratie via entry l ontvangen via accept u boodschap versturen l geen nieuwe term of constructie l analoog aan het oproepen van een procedure of een protected entry

SGP slide 92Systeem-geïntegreerde programmatuurYolande Berbers het boodschappenmodel in Ada Task Time_Server is entry Read_Time (Now: out Time); entry Set_Time (New_Time: Time); end Time_Server ; n declaratie van ontvangst van boodschap: entry n parameters = inhoud van boodschappen (aanvraag en antwoord) Time_Server.Read_Time(T) -- met T van type Time n zenden van een boodschap = oproepen van een taak = vragen om een rendez-vous (dit is blokkerend) l opgeroepen taak wordt benoemd: directe benoeming l oproepende taak zal wachten op resultaat: niet-locale invocatie

SGP slide 93Systeem-geïntegreerde programmatuurYolande Berbers het boodschappenmodel in Ada accept Read_Time (Now: out Time) do Now := Clock; end Read_Time; n ontvangen van een boodschap = aanvaarden van een rendez-vous (dit is blokkerend) n accept-bevel l moet in body van taak voorkomen (niet in opgeroepen procedure) l mag om het even waar in body van taak staan (bv midden in lus) n accept geeft niet aan met wie men een rendez-vous aanvaardt: benoeming is dus asymmetrisch n 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 slide 95Systeem-geïntegreerde programmatuurYolande Berbers uitzonderingen tijdens rendez-vous n opvangen van uitzondering in blok van de accept-code u uitzondering wordt opgevangen: geen probleem u uitzondering wordt niet opgevangen: l accept eindigt onmiddellijk l de uitzondering propageert s in de omsluitende blok van de accept-code s 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 slide 97Systeem-geïntegreerde programmatuurYolande Berbers selectief wachten n situatie: ontvanger wenst te wachten op een boodschap uit een groep van mogelijkheden u elke mogelijkheid kan voorafgegaan worden door wachter-test u wanneer meerdere mogelijkheden open zijn (hetzij omdat de wachter-test true is, hetzij omdat er geen wachter test is) l run-time systeem kiest één uit op niet-deterministisch manier l vgl: if x = y then m := y (dit is wel deterministisch)

SGP slide 98Systeem-geïntegreerde programmatuurYolande Berbers selectief wachten n constructie in Ada: u sleutelwoord select (te vergelijken met een case) u 4 mogelijkheden: l accept l else-alternatief s wordt gekozen alleen indien geen enkel ander alternatief onmiddellijk uitvoerbaar is l delay-alternatief s hierbij wordt een tijdje gewacht (zie hoofdstuk 12) l terminate s wordt gekozen alleen indien geen enkele andere taak nog een rendez-vous kan doen s in dat geval wordt de taak van de select geëindigd

selectief wachten: voorbeeld task Telephone_Operator is entry Directory_Enq (P : in Name; Num: out Number); entry Report_Fault (Num: Number); private entry 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 request select accept Directory_Enq (P : in Name; Num: out Number) do..... end Directory_Enquiry; or accept Report_Fault (Num: Number) do..... end Report_Fault; -- change Unallocated_Faults or when Unallocated_Faults => accept Allocate_Repair_Worker (Num: out Number) do..... end Allocate_Repair_Worker ; or terminate; end select; end loop; selectief wachten: voorbeeld

SGP slide 101Systeem-geïntegreerde programmatuurYolande Berbers boodschappenmodel bij POSIX n belangrijkste characteristieken u synchronisatiemodel:asynchroon u procesbenoeming:indirect, symmetrisch u structuur van boodschappen:vrij n terminologie u boodschap wordt verstuurd en ontvangen van message queue l kan vele lezers en vele schrijvers hebben l bij de creatie kan men o.a. ook opgeven: lengte queue, maximale grootte van een individuele boodschap, protectie l in het normaal geval zal een proces wachten als de message queue vol is (bij zenden) of leeg is (bij ontvangen) l proces kan ook verwittigd worden van boodschap via signal

SGP slide 102Systeem-geïntegreerde programmatuurYolande Berbers boodschappenmodel bij POSIX n een queue krijgt een naam bij creatie (analoog aan bestandsnaam) n 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 slide 103Systeem-geïntegreerde programmatuurYolande Berbers boodschappenmodel bij POSIX n 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 slide 104Systeem-geïntegreerde programmatuurYolande Berbers resultaat bevraging te uitgebreid want niet interessant want overlapt OKmag meer inleiding algemeen stuk, voorbeelden1226 inleiding alg. stuk, karakteristieken2 27 inleiding alg. stuk, vb van ariane achtergrond Ada met voor en nadelen2 26 Java voor embedded systems Ada crash course: prog. in the small 1811 Ada crash course: prog. in the large 1514 con. prog.: multi-tasking problematiek concurrent prog.: multi-tasking: POSIX81201 concurrent prog.: multi-tasking: Ada 264

SGP slide 105Systeem-geïntegreerde programmatuurYolande Berbers resultaat bevraging te uitgebreid want niet interessant want overlapt OKmag meer conc. prog.: shared mem: problematiek 8221 conc. prog.: shared mem: POSIX7121 conc. prog.: shared mem: Ada 264 conc prog.: boodsch: problematiek 7204 conc. prog.: boodsch: POSIX7221 conc. prog.: boodsch: Ada 264