Om een of andere reden kan het computersysteem van de zeehaven nog steeds niet communiceren met het aanmeerprogramma van je veerboot. Het zal waarschijnlijk versie 2 van de decodeerchip gebruiken!

Versie 2 van de decodeerchip verandert de waarden die naar het geheugen worden geschreven helemaal niet. In plaats daarvan fungeert het als een geheugenadresdecoder¹. Vlak voor een waarde naar het geheugen wordt geschreven, wijzigt elke bit in de bitmask op de volgende manier de corresponderende bit van het bestemmingsgeheugenadres:

• als de bit van de bitmask 0 is, dan blijft de corresponderende bit van het geheugenadres ongewijzigd.
• als de bit van de bitmask 1 is, dan wordt de corresponderende bit van het geheugenadres overschreven met 1.
• als de bit van de bitmask X is, dan is de corresponderende bit van het geheugenadres drijvend.

Een drijvend bit is nergens mee verbonden en verandert in plaats daarvan op een onvoorspelbare manier. In de praktijk betekent dit dat de drijvende bits alle mogelijke waarden zullen aannemen, waardoor mogelijk naar veel geheugenadressen tegelijk wordt geschreven!

Stel dat we bijvoorbeeld het volgende programma hebben:

mask = 000000000000000000000000000000X1001X
mem[42] = 100
mask = 00000000000000000000000000000000X0XX
mem[26] = 1

Als dit programma naar geheugenadres 42 gaat schrijven, past het eerst de bitmask toe:

adres:     000000000000000000000000000000101010  (decimaal 42)
bitmask:   000000000000000000000000000000X1001X
resultaat: 000000000000000000000000000000X1101X

Na het toepassen van de bitmask worden vier bits overschreven, waarvan er drie verschillend zijn en twee drijvend. Zwevende bits nemen elke mogelijke combinatie van waarden aan. Met twee drijvende bits worden daadwerkelijk vier geheugenadressen geschreven:

000000000000000000000000000000011010  (decimaal 26)
000000000000000000000000000000011011  (decimaal 27)
000000000000000000000000000000111010  (decimaal 58)
000000000000000000000000000000111011  (decimaal 59)

Daarna staat het programma op het punt om met een andere bitmask naar geheugenadres 26 te schrijven:

adres:     000000000000000000000000000000011010  (decimaal 26)
bitmask:   00000000000000000000000000000000X0XX
resultaat: 00000000000000000000000000000001X0XX

Dit resulteert in een adres met drie drijvende bits, waardoor er naar acht geheugenadressen wordt geschreven

000000000000000000000000000000010000  (decimaal 16)
000000000000000000000000000000010001  (decimaal 17)
000000000000000000000000000000010010  (decimaal 18)
000000000000000000000000000000010011  (decimaal 19)
000000000000000000000000000000011000  (decimaal 24)
000000000000000000000000000000011001  (decimaal 25)
000000000000000000000000000000011010  (decimaal 26)
000000000000000000000000000000011011  (decimaal 27)

Elk adres van de volledige 36-bit adresruimte is initieel nog steeds ingesteld op de waarde 0, en je hebt nog steeds de som nodig van alle waarden die in het geheugen zijn achtergebleven nadat het initialisatieprogramma voltooid is. In dit voorbeeld is de som 208.

Opgave

Voer het initialisatieprogramma uit met een emulator voor versie 2 van de decodeerchip. Wat is de som van alle waarden die in het geheugen zijn achtergebleven nadat het programma voltooid is? Hiervoor ga je als volgt te werk:

• Schrijf een functie memory waaraan de padnaam (str) moet doorgegeven worden van een tekstbestand met een initialisatieprogramma. De functie moet de som (int) teruggeven van alle waarden die in het geheugen zijn achtergebleven nadat het programma voltooid is.

Voorbeeld

In deze interactieve sessie gaan we ervan uit dat het tekstbestand program.txt² zich in de huidige directory bevindt.

>>> memory('program.txt')
208