hoofdstuk 10: atomaire acties, gelijktijdige processen en betrouwbaarheid

1. hoofdstuk 10:atomaire acties, gelijktijdige processen en betrouwbaarheid

2. overzicht • atomaire acties • definitie en eigenschappen • ondersteuning voor atomaire acties in programmeertalen • atomaire acties en achterwaarts herstel (voorlopig niet) • atomaire acties en voorwaarts herstel (voorlopig niet) • asynchrone events, signalen en asynchrone transfer van controle • signalen in POSIX • asynchrone transfer van controle in Ada (voorlopig niet)

3. 3 soorten relaties tussen processen • onafhankelijke processen (geen comm. of synchronisatie) • als een proces faalt heeft dit geen invloed op andere processen • betrouwbaarheid door gebruik van herstelblokken en het behandelen van uitzonderingen • samenwerkende processen (wel comm. of synchronisatie) • als een fout in 1 proces optreedt kan dit invloed hebben op andere processen • dit behandelen we in dit hoofdstuk • processen in competitie voor hulpmiddelen • synchronisatie voor de hulpmiddelen • fout in 1 proces mag geen invloed hebben op andere processen • zie hoofdstuk 11

4. atomaire acties • voor één actie moet er soms meer dan eens gecommuniceerd en gesynchroniseerd worden • vb: overschrijven van geld van rekening A naar rek. B • authenticatie van degene die het geld overschrijft • nakijken of er genoeg geld op rekening A staat • werkelijk afhalen van het geld • geld op rekening B plaatsen • van belang: alle processen zien consistente toestand • zo een aantal gezamenlijke handelingen moeten ‘ondeelbaar’ uitgevoerd worden: buitenwereld ziet geen tussentoestanden(bv buitenwereld ziet nooit een moment dat geld afgehaald is op rekening A maar nog niet gestort is op rekening B) • dit heet atomaire actie

5. atomaire acties • wanneer hulpmiddelen nodig zijn (bv bestanden) dan gebeurt dat in twee fasen • groeiende fase • de hulpmiddelen worden aangevraagd • krimpende fase • de hulpmiddelen worden weer vrijgegeven • deze fazen zijn strikt gescheiden • bv niet eerst geld afhalen van rekening A en die al vrijgeven voordat rekening B aangevraagd is • in dat geval zou een buitenstaander kunnen zien dat er geld afgehaald is op rekening A maar nog niet gestort is op rekening B

6. atomaire acties • atomaire transacties • eigenschap: alles of niets (als een fout optreedt wordt de begintoestand automatisch hersteld) • dit wordt door het systeem ondersteund (zie hoofdstuk 14) • programmeur heeft dan ook geen vat op deze ondersteuning (bv herstel procedures kunnen niet opgegeven worden) • is een vorm van achterwaarts herstel, laat geen voorwaarts herstel toe • veel gebruikte term bij besturingsystemen en gegevensbanken • worden soms ook wel herstelbare acties of atomaire acties genoemd

7. atomaire acties • vereisten voor atomaire acties • welbepaalde grenzen • start • beginplaats in elk proces dat deel uitmaakt van atomaire actie • einde • eindplaats in elk proces dat deel uitmaakt van atomaire actie • zij-grenzen • dit scheidt de processen die deel uitmaken van atomaire actie van andere processen • atomaire acties kunnen genest zijn • alleen strikte nesting (processen die betrokken zijn bij de geneste actie moeten een subset zijn van degene uit actie)

8. atomaire acties • vereisten voor atomaire acties • ondeelbaarheid • geen communicatie tussen de processen die deel uitmaken van de atomaire actie en andere processen in het systeem (behalve beheerders van hulpmiddelen) • vb: gedeelde variabele tussen 2 atomaire acties: deze kunnen alleen strikt na elkaar uitvoeren • geen synchronisatie bij begin nodig, wel bij het einde • een proces kan atomaire actie pas verlaten als alle processen die deel uitmaken van atomaire actie gedaan hebben en ook bereid zijn de atomaire actie te verlaten • totaal verschillende atomaire acties kunnen gelijktijdig uitvoeren • effect zal zelfde zijn dan wanneer strikt na elkaar uitvoeren

9. atomaire acties P1 P2 P3 P4 P5 P6 tijdsas actie A geneste actie B

10. atomaire acties in programmeertalen • geen enkele huidige programmeertaal biedt taalondersteuning voor atomaire acties • de semantiek van een atomaire actie kan gerealiseerd worden met behulp van • semaforen (zie boek, goed extra voorbeeld van semaforen) • monitors (zie boek, goed extra voorbeeld van monitors) • protected objects (zie volgende slides) (voorlopig niet)

11. atomaire acties in Ada • wanneer er maar twee processen betrokken zijn is het rendez-vous mechanisme voldoende • meer dan twee processen: geen taal-ondersteuning voor atomaire acties • alternatief: creëer een ‘actie-controller’ (een protected object) die het geheel synchroniseert (zie de drie volgende slides) • elk proces dat deel uitmaakt van de atomaire actie zal zijn begin melden door een entry op te roepen • wanneer proces zijn deel van atomaire actie gedaan heeft, zal proberen de actie te verlaten door ‘finished’ entry op te roepen • deze heeft een wachter, die pas de entry opent wanneer alle processen die deel uitmaken van de actie aan de entry wachten

12. atomaire acties in Ada package Action_X is procedure Code_For_First_Task (--params); procedure Code_For_Second_Task (--params); procedure Code_For_Third_Task (--params); end Action_X; package body Action_X is protected Action_Controller is entry First; entry Second; entry Third; entry Finished; private First_Here : Boolean := False; Second_Here : Boolean := False; Third_Here : Boolean := False; Release : Boolean := False; end Action_Controller ;

13. atomaire acties in Ada protected body Action_Controller is entry First when not First_Here is begin First_Here := True; end First; -- analoog voor Second en voor Third entry Finished when Released or Finished’Count = 3 is begin if Finished’Count = 0 then Release := False; First_Here := False; Second_Here := False; Third_Here := False; else Release := True; end if ; end Finished; end Action_Controller ;

14. atomaire acties in Ada procedure Code_For_First_Task (-- params) is begin Action_Controller.First; -- eerst worden de nodige hulpmiddelen aangevraagd -- en daarna wordt de actie zelf uitgevoerd Action_Controller.Finished; -- nu kunnen de hulpmiddelen vrij gegeven worden end Code_For_First_Task; -- analoog voor tweede en voor derde taak begin -- initalisaties die nodig zijn end Action_X ;

15. atomaire acties en achterwaarts herstel • herstel van verschillende gelijktijdig uitvoerende processen kan moeilijk zijn • achterwaarts herstel kan leiden tot het domino effect (zie hoofdstuk 5, herhaling op volgende slide) • probleem omdat er geen consistente herstellijn is bij alle processen (een herstellijn bevat herstelpunten in alle processen) • bij atomaire actie is deze consistente herstellijn er wel: de verzameling van de beginpunten in alle processen van atomaire actie • momenteel biedt geen enkele taal hiervoor echte ondersteuning • systemen die hiervoor ondersteuning geven bieden atomaire transacties aan • in het boek worden een aantal voorstellen besproken: conversaties, dialogen en colloquia (hoef je niet te kennen)

16. R11 R21 R12 R22 R13 domino-effect (herhaling uit H. 5) P1 P2 interactie herstelpunt tijdsas detectie

17. atomaire acties en voorwaarts herstel • wanneer een fout optreedt moet dit doorgegeven worden aan alle deelnemende processen • een fout die op die manier doorgegeven wordt aan een proces is asynchroon, omdat de fout niets te maken heeft met wat het ontvangende proces op dat moment aan het uitvoeren is • (dit is ook waar voor achterwaarts herstel) • bij ontvangst van een asynchrone uitzondering • zowel beëindigingsmodel als voortzettingsmodel mogelijk

18. atomaire acties en voorwaarts herstel • mogelijke problemen bij het optreden van uitzonderingen • verschillende uitzonderingen kunnen in verschillende processen gelijktijdig optreden • bv in proces A treedt uitzondering X op, in proces B uitzondering Y • welke uitzondering moet een proces C nu behandelen ? • mogelijke oplossing: uitzonderingsboom (details: zie boek) • een uitzondering treedt op terwijl gelijktijdig een geneste atomaire actie bezig is (die ondeelbaar is en niet zomaar gestopt kan worden) • voor mogelijke oplossingen: zie boek

19. asynchrone events • ondersteuning voor asynchrone uitzonderingen: onbestaand in huidige programmeertalen en besturingssystemen • ondersteuning voor asynchrone events: bestaat wel • mechanisme waarbij een proces A de aandacht van proces B kan vragen, zonder dat B expliciet hierop moet wachten • mechanisme kan gebruikt worden voor foutherstel in systemen met gelijktijdige uitvoerende processen • proces B definieert per soort event een behandelingsroutine (handler) die opgeroepen moet worden wanneer het overeenkomstige event toekomt • twee modellen mogelijk (zie volgende slide): het voortzettingsmodel en het beëindigingsmodel

20. asynchrone events • ondersteuning voor asynchrone events • twee modellen mogelijk • het voortzettingsmodel • komt overeen met een software-interrupt • voorbeeld: POSIX (zie verder) • het beëindigingsmodel • ontvangend proces definieert een domein waarbinnen het bereid is asynchrone events te ontvangen • na de behandeling van het event zal de controle terugkeren naar een andere plaats • Ada supporteert dit • het maakt het run-time systeem een stuk ingewikkelder door deze transfer van controle

21. asynchrone events • nood aan asynchrone events • in bepaalde omstandigheden moet een proces snel reageren op bepaalde gebeurtenissen • pollen of wachten is vaak niet aangewezen • herstel van fouten • voor het ondersteunen van atomaire acties • verandering van uitvoeringsmodus • sommige toepassing werken in verschillende fazen; in elke faze spreekt men van een andere uitvoeringsmodus (bv bij een vliegtuig: opstijgen, normaal vliegen, landen, noodtoestand) • veranderen van modus kan verwacht zijn of heel plots gebeuren • berekeningen die steeds verfijnd kunnen worden (zie volgende slide) • gebruikersinterrupts (zie volgende slide)

22. asynchrone events • nood aan asynchrone events • berekeningen die steeds verfijnd kunnen worden • veel algoritmen bereiken een juister resultaat als langer kan gerekend worden • voorbeelden: numerieke berekeningen (PDE), heuristisch zoeken (beste zet in schaak) • scheduling bepaalt wanneer antwoord nodig is; er wordt verder gerekend totdat asynchroon event komt • gebruikersinterrupts • in een interactieve omgeving kan de gebruiker plots willen ingrijpen (del-toets indrukken, of klikken op een knop die de modus verandert)

23. signalen bij POSIX • POSIX-signalen worden gebruikt • om fouten door de omgeving gedetecteerd door te geven • bv onbekende instructie (SIGILL), wijzer buiten de grenzen (SIGSEGV) • om vooraf gedefinieerde events door te geven: • bv timer loopt af (SIGALARM), gebruiker geeft ‘kill’-signaal door (SIGKILL) • om toepassingsgedefinieerde events door te geven: SIGRTMIN .. SIGRTMAX • behandeling van signalen • elk signaal heeft een default-handler • voor elk signaal kan de gebruiker een andere handler definiëren • per signaal kan de gebruiker specifiëren: tegenhouden, negeren of behandelen

24. signalen bij POSIX • behandeling van signalen • tegengehouden signalen • kunnen gemanipuleerd worden op verschillende manieren, o.a. later doorgelaten worden • signalen die genegeerd worden hebben geen effect • er zijn zeer vele routines (met telkens de nodige parameters) om met signalen om te gaan (klassiek voor POSIX !) • signalen en threads • signalen werden ingevoerd vóórhet concept ‘threads’, dus in de veronderstelling dat een proces slechts 1 controledraad heeft • sommige signalen hebben semantisch meer betekenis voor een thread, andere voor het hele proces • dit maakt het geheel niet doorzichtiger

25. POSIX signals • handling a signal: define handler with sigaction struct sigaction { void (*sa_handler) (int signum); /* non real-time handler */ void (*sa_sigaction) (int signum, signinfo_t *data, void *extra); /* real-time handler */ sigset_t sa_mask; /* signals to mask during handler */ int sa_flags; /* indicates if signal is to be queued */ } int sigaction (int sig, const struct sigaction *reaction, struct sigaction *old_reaction); /* sets up a signal handler, reaction, for sig */

26. POSIX signals • blocking a signal • function sigprocmask to manipulate mask • functions to manipulate set int sigprocmask (int how, const sigset_t *set, sigset_t *oset); /* manipulates a signal mask according ot the value of how: how = SIG_BLOCK: set is added to current set how = SIG_UNBLOCK: set is subtracted how = SIG_SETMASK: given set becomes mask */ int sigemtpyset (sigset_t *s); /* initialize a set to empty */ int sigaddset (sigset_t *s, int signum); /* add a signal to a set */ int sigdelset (sigset_t *s, int signum); /* remove a signal from set */

27. POSIX signals • example: computation depends on system-wide mode; mode change propagated through signal # include <signal.h> # define MODE_A 1 # define MODE_B 2 # define MODE_CHANGE SIGRTMIN + 1 int mode = MODE_A void change_mode (int signum, siginfo_t *data, void *extra) { /* signal handler */ mode = data -> si_value.sival_int; }

28. int main () { sigset_t mask, omask; struct sigaction s, os; int local_mode; SIGEMPTYSET (&mask); SIGADDSET (&mask, MODE_CHANGE); s.sa_flags = SA_SIGINFO; s.sa_mask = mask; s.sa_sigaction = &change_mode; s.sa_handler = &change_mode; SIGACTION (MODE_CHANGE, &s, &os); /* assign handler */ POSIX signals while (1) { SIGPROCMASK (SIG_BLOCK, & mask, &omask); local_mode = mode; SIGPROCMASK (SIG_UNBLOCK, &mask, &omask); switch (local_mode) { case MODE_A: …… break; case MODE_B: …… break; default: …… } } }

29. asynchrone controletransfer in Ada • asynchrone controletransfer in Ada maakt gebruik van het communicatiemechanisme tussen taken select -- wachten op mogelijk event (niet oproepen !) -- zolang geen rendez-vous optreedt wordt normale actie uitgevoerd Trigger.Event; -- optioneel kunnen hier bevelen staan die uitgevoerd worden -- nadat het event ontvangen werd then abort -- normale actie (code die onderbroken kan worden) end select;

30. asynchrone controletransfer in Ada • ipv triggering event kan er ook een delay staan (zie hoofdstuk 12) • het kan gebeuren dat de rendez-vous plaatsvindt voordat de normale actie begonnen is

31. asynchrone controletransfer in Ada task Server is entry ATC_Event; end Server; task To_be_Interrupted; task body Server is begin ... accept ATC_Event do Seq2; end ATC_Event; ... end Server;

32. asynchrone controletransfer in Ada task body To_be_Interrupted is begin ... select Server.ATC_Event; Seq3; then abort Seq1; end select; Seq4; ... end To_be_Interrupted;

33. asynchrone controletransfer in Ada • beschrijving van semantiek door alle mogelijke volgordes van uitvoering: • indien het rendez-vous klaar is bij binnenkomen van select • Server.ATC_Event wordt uitgevoerd • Seq2 wordt uitgevoerd • Seq3 wordt uitgevoerd • Seq4 wordt uitgevoerd • (Seq1 werd nooit begonnen) • indien geen rendez-vous start voordat Seq1 eindigt • Server.ATC_Event wordt uitgevoerd • Seq1 wordt uitgevoerd • Server.ATC_Event wordt geannuleerd • Seq4 wordt uitgevoerd

34. asynchrone controletransfer in Ada • indien het rendez-vous eindigt voordat Seq1 eindigt • Server.ATC_Event wordt uitgevoerd • gedeeltelijke uitvoering van Seq1 gelijktijdig met Seq2 • Seq1 wordt gestopt • Seq3 wordt uitgevoerd • Seq4 wordt uitgevoerd • indien het rendez-vous eindigt nadat Seq1 eindigt • Server.ATC_Event wordt uitgevoerd • uitvoering van Seq1 gelijktijdig met Seq2 • Server.ATC_Event wordt geannuleerd maar dit lukt niet • uitvoering van Seq2 gaat door tot einde • Seq3 wordt uitgevoerd • Seq4 wordt uitgevoerd

35. asynchrone controletransfer in Ada • ATC kan gebruikt worden om zowel achterwaarts herstel als voorwaarts herstel bij atomaire acties te programmeren • achterwaarts herstel • maakt gebruik van een controler protected object • elk proces kan deze controler verwittigen als er iets misloopt • in dat geval zal de controler gebruik maken van ATC om de andere processen van de atomaire actie te stoppen • de controller synchroniseert ook het einde van atomaire actie • volgende slides: enkel meest belangrijke stukken code, zie boek voor volledige code

36. asynchrone controletransfer in Ada protected Controller is entry Wait_Abort_Action; entry Done; procedure Signal_Abort; -- variabelen end Controller; protected body Controller is entry Wait_Abort_Action when Killed is .... -- rendez-vous wordt aangegaan om normale acties te stoppen end Wait_Abort_Action; procedure Signal_Abort is begin Killed := True; end Signal_Abort; entry Done when Done’Count = 3 or Releasing is ... end Done; end Controller;

37. asynchrone controletransfer in Ada procedure T1_Deel_van_Atomaire_Actie_Primary is begin select Controller.Wait_Abort_Action; Controller.Done; raise Primary_Failure; then abort begin -- normale code van dit deel van de atomaire actie Controller.Done; exception when other => Controller.Signal_Abort; end ; end select; end T1_Deel_van_Atomaire_Actie_Primary ;

38. asynchrone controletransfer in Ada • voorwaarts herstel • maakt gebruik van een controler protected object • elk proces kan deze controler verwittigen als er iets misloopt • in dat geval zal de controler gebruik maken van ATC om de andere processen van de atomaire actie te stoppen • exception wordt veroorzaakt in elk proces door expliciete raise na het rendez-vous dat de normale actie stopt • in exception gedeelte wordt aan voorwaarts herstel gedaan • als dit bij alle processen van de atomaire actie lukt, dan is de atomaire actie succesvol • dit wordt door het controller object gesynchroniseerd: elk proces geeft door of het gelukt is (Commit of Aborted) en wacht op de globale beslissing (Decision)

39. asynchrone controletransfer in Ada procedure T1_Deel_van_Atomaire_Actie is begin select Controller.Wait_Abort_Action (X); raise X; then abort begin -- normale code van dit deel van de atomaire actie Controller.Done (Commit); Controller.Wait (Decision); exception when E: others =>Controller.Signal_Abort (E); end ; end select; exception ... (zie volgende slide) end T1_Deel_van_Atomaire_Actie;

40. asynchrone controletransfer in Ada ... exception when E: others => -- behandel de uitzondering en zet Handle_Ok op True of False if Handle_Ok then Controller.Done (Commit); Controller.Wait (Decision); else Controller.Done (Aborted); Controller.Wait (Decision); end if; if Decision = Aborted then raise Atomic_Action_Failure; end T1_Deel_van_Atomaire_Actie;

41. asynchrone controletransfer in Ada protected body Controller is entry Wait_Abort_Action (E: out Exception_Id) when Killed is.... end; -- rendez-vous wordt aangegaan om normale acties te stoppen procedure Signal_Abort (E: Exception_Id) is begin Killed := True; Reason := E; end Signal_Abort; procedure Done (Vote: Vote_T) is begin if Vote = Aborted then Final_Result := Aborted; end if; end Done: entry Wait (Result : out Vote_T) when Wait’Count = 3 or Releasing is begin Result := Final_Result; ... end Done; end Controller;