hoofdstuk 10 atomaire acties gelijktijdige processen en betrouwbaarheid
Download
Skip this Video
Download Presentation
hoofdstuk 10: atomaire acties, gelijktijdige processen en betrouwbaarheid

Loading in 2 Seconds...

play fullscreen
1 / 41

hoofdstuk 10: atomaire acties, gelijktijdige processen en betrouwbaarheid - PowerPoint PPT Presentation


  • 414 Views
  • Uploaded on

hoofdstuk 10: atomaire acties, gelijktijdige processen en betrouwbaarheid. overzicht. atomaire acties definitie en eigenschappen ondersteuning voor atomaire acties in programmeertalen atomaire acties en achterwaarts herstel (voorlopig niet)

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'hoofdstuk 10: atomaire acties, gelijktijdige processen en betrouwbaarheid' - HarrisCezar


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
overzicht
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 soorten relaties tussen processen
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
atomaire acties
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
atomaire acties5
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
atomaire acties6
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
atomaire acties7
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)
atomaire acties8
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
atomaire acties9
atomaire acties

P1

P2

P3

P4

P5

P6

tijdsas

actie A

geneste actie B

atomaire acties in programmeertalen
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)
atomaire acties in ada
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
atomaire acties in ada12
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 ;

atomaire acties in ada13
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 ;

atomaire acties in ada14
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 ;

atomaire acties en achterwaarts herstel
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)
domino effect herhaling uit h 5
R11

R21

R12

R22

R13

domino-effect (herhaling uit H. 5)

P1

P2

interactie

herstelpunt

tijdsas

detectie

atomaire acties en voorwaarts herstel
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
atomaire acties en voorwaarts herstel18
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
asynchrone events
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
asynchrone events20
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
asynchrone events21
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)
asynchrone events22
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)
signalen bij posix
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
signalen bij posix24
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
posix signals
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 */

posix signals26
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 */

posix signals27
POSIX signals
  • example: computation depends on system-wide mode; mode change propagated through signal

# include

# 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;

}

posix signals28
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: ……

}

}

}

asynchrone controletransfer in ada
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;

asynchrone controletransfer in ada30
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
asynchrone controletransfer in ada31
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;

asynchrone controletransfer in ada32
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;

asynchrone controletransfer in ada33
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
asynchrone controletransfer in ada34
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
asynchrone controletransfer in ada35
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
asynchrone controletransfer in ada36
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;

asynchrone controletransfer in ada37
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 ;

asynchrone controletransfer in ada38
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)
asynchrone controletransfer in ada39
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;

asynchrone controletransfer in ada40
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;

asynchrone controletransfer in ada41
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;

ad