Mutual Exclusion

Mutual exclusion is Engels voor 'wederzijdse uitsluiting'. Deze term staat voor een mechanisme dat ervoor moet zorgen dat twee routines niet 'tegelijkertijd' van dezelfde variabele gebruik maken. Dit probleem, dat zich bij interrupt routines kan voordoen, kan het best worden beschreven aan de hand van het voorbeeld.

Het hoofdprogramma roept de routine 'checktimeout' aan. Stel dat in deze routine de interrupts niet tijdelijk geblokkeerd zouden worden. De routine ziet er dan als volgt uit:

checktimeout equ $
pshb
ldab rticount                 |kijk hoe vaak er een interrupt was
subb #rtirate                 |indien er minimaal 'rtirate' interrupts
blo checktimeout9             |zijn geweest, dan is er een time-out en moet
stab rticount                 |'rtirate' van de teller worden afgetrokken
clrb                          |daarnaast moet de zero-vlag gezet worden
checktimeout9 pulb
rts

De interrupt routine verhoogt bij iedere real time interrupt de variabele 'rticount'

rtiintentry equ $
ldab #rtif
stab tflg2                    |reset de interrupt﷓vlag
inc rticount                  |en tel de interrupt
rti

Het hoofdprogramma kan op elk willekeurig moment door de interrupt routine onderbroken worden. Stel dat de interrupt optreedt, juist nadat het hoofdprogramma de instructie 'ldab rticount' heeft uitgevoerd, en dat deze de waarde 'rtirate' bevat. De interrupt routine wordt nu toevallig actief, en de variabele 'rticount' wordt verhoogd. De variabele krijgt daardoor de waarde 'rtirate+1'. Daarna keert de processor terug naar het hoofdprogramma. Hier gaat het programma verder met de instructie 'subb #rtirate'. Dit levert 0 op (want in B staat nog steeds de waarde 'rtirate'.) Deze 0 wordt teruggeschreven in de variabele 'rticount'. Nu is er een interrupt te weinig geteld in 'rticount'. De interrupt is weliswaar geteld door de interrupt routine, maar het hoofdprogramma heeft de tellerwaarde weer overschreven.

Het probleem doet zich alleen voor, als zowel het hoofdprogramma als een interrupt routine 'tegelijkertijd' gebruik kunnen maken van een variabele (of een I/O register.) Een afdoende oplossing is, ervoor te zorgen dat een interrupt routine geblokkeerd wordt op het moment dat het hoofdprogramma de variabele gebruikt.

Wanneer een interrupt routine actief is, kan deze niet onderbroken worden door het hoofdprogramma. De interrupt routine sluit het hoofdprogramma uit. Als nu het hoofdprogramma ook de interrupt routine op de kritieke momenten uitsluit (door de interrupts te blokkeren), is er sprake van wederzijdse uitsluiting ('mutual exclusion'.) Dit lost het probleem op.

checktimeout equ $
pshb
ldab rticount

!!Hier onderbreekt een interrupt het hoofdprogramma, en verhoogt de
  waarde in rticount. Het hoofdprogramma rekent echter verder met de
  'verouderde' waarde van rticount.

subb #rtirate               B bevat een verouderde waarde (1 te klein)
blo checktimeout9
stab rticount               De berekende waarde (die 1 te klein is)
                            wordt teruggeschreven.
clrb
checktimeout9 pulb
rts