32-bit ALU

Bij het invoeren van numerieke waarden in de antwoordvelden kunt u gebruik maken van gehele getallen (1000, 0x3E8, 0b1111101000), floating-point getallen (1000.0), wetenschappelijke notatie (1e3), technische schaalfactoren (1K), of numerieke expressies (3*300 + 100) gebruiken.Nuttige links:

• Inleiding tot Jade
• Standaardcellenbibliotheek

Opgave 1. Design Problem: 32-bit Arithmetic and Logic UnitZie de instructies hieronder.Gebruik de Jade instance hieronder om uw ontwerp in te voeren. Om dit ontwerpprobleem te voltooien, selecteer de /alu/alu module en klik in de Jade toolbar en de ingebouwde tester zal ofwel discrepanties rapporteren tussen de verwachte en de werkelijke output, of, als je ontwerp correct is, zal het registreren dat de test geslaagd is.{ “shared_modules”: , “hierarchical”: “true”, “parts”: , “tools”: , “editors”: , “edit”: ,”/alu/alu”, “required_tests”: }In dit practicum bouwen we de rekenkundige en logische eenheid (ALU) voor de Beta processor. De ALU heeft twee 32-bit ingangen (die we “A” en “B” zullen noemen) en produceert één 32-bit uitgang. We beginnen met het ontwerp van elk onderdeel van de ALU als een afzonderlijke schakeling, die elk zijn eigen 32-bits uitgang produceert. Daarna combineren we deze uitgangen tot een enkel ALU-resultaat.Bij het ontwerpen van schakelingen zijn er drie factoren die geoptimaliseerd kunnen worden:

1. ontwerp voor maximale prestaties (minimale latency)
2. ontwerp voor minimale kosten (minimale oppervlakte)
3. ontwerp voor de beste kosten/prestatie verhouding (minimaliseer oppervlakte*latency)

Gelukkig is het vaak mogelijk om alle drie tegelijk te doen, maar in sommige delen van de schakeling zal een soort afweging gemaakt moeten worden. Bij het ontwerpen van je schakeling moet je kiezen welke van de drie factoren het belangrijkst voor je is en je ontwerp daarop afstemmen. De standaard celbibliotheek & gate-level simulatie De bouwstenen voor dit lab komen uit een bibliotheek van logische poorten – IC-fabrikanten hebben vaak een “standaard celbibliotheek” en verschillende ontwerphulpmiddelen om het voor hun klanten gemakkelijker te maken te ontwerpen zonder zich zorgen te hoeven maken over de gedetailleerde geometrie van de maskerlagen die worden gebruikt om mosfets en bedrading te maken. 6.004 heeft zijn eigenStandard Cell Library die voorziet in:

Zie de bibliotheekdocumentatie voor details over de juiste aansluitingen voor elke gate. In Jade zijn de gates in de standaard celbibliotheek te vinden in de parts bin onder “/gates/”.

Omdat we op poortniveau ontwerpen, kunnen we een fastersimulator gebruiken die alleen gates en logische waarden kent (in plaats van transistors en spanningen). Merk op dat uw ontwerp geen mosfets, weerstanden, condensatoren, enz. kan bevatten; de simulator op poortniveau ondersteunt alleen de poort-primitieven in de standaard celbibliotheek.Ingangen worden nog steeds gespecificeerd in termen van spanningen (om compatibiliteit met de andere simulators te behouden), maar de gate-level-simulator converteert spanningen naar een van de drie mogelijke logische waarden, gebruikmakend van de vil en vih drempelwaarden die aan het begin van uw ontwerpbestand zijn gespecificeerd:

Een vierde waarde “Z” wordt gebruikt om de waarde weer te geven van knooppunten die niet worden aangestuurd door een gate uitgang (b.v.g., de uitgangen van tristatedrivers die niet zijn ingeschakeld). Het volgende diagram toont hoe deze waarden op het golfvorm-display verschijnen:

ALU specificatieDe 32-bit ALU die we zullen bouwen zal een component zijn in de Betaprocessor die we in volgende laboratoria zullen behandelen. Het logicasymbool voor onze ALU staat rechts afgebeeld. Het is een combinatorische schakeling die twee 32-bits datawoorden A en B als inputs neemt, en een 32-bits output Y produceert door een gespecificeerde rekenkundige of logische functie uit te voeren op de A en B inputs. De uit te voeren functie wordt gespecificeerd door een 6-bit controle-ingang, FN, waarvan de waarde de functie codeert volgens de onderstaande tabel:

00-011

FN	Werking	Uitgangswaarde Y
CMPEQ	Y = (A == B)
00-101	CMPLT	Y = (A < B)
00-111	CMPLE	Y = (A ≤ B)
01—0	32-bit ADD	Y = A + B
01—1	32-bit SUBTRACT	Y = A – B
10abcd	Bit-wise Boolean	Y = Fabcd(A,B)
11–00	Logische verschuiving naar links (SHL)	Y = A << B
11–01	Logical Shift right (SHR)	Y = A >> B
11–11	Arithmetic Shift right (SRA)	Y = A >> B (sign extended)

Merk op dat door het specificeren van een geschikte waarde voor de 6-bit FNinput, de ALU een verscheidenheid aan rekenkundige bewerkingen, vergelijkingen, verschuivingen, en bitwise Booleaanse combinaties kan uitvoeren die onze Beta processor nodig heeft.

De bitwise Booleaanse operaties worden gespecificeerd door FN=10; in dit geval worden de resterende FN-bits abcd genomen als punten in de waarheidstabel die beschrijft hoe elk bit van Y wordt bepaald door de overeenkomstige bits van A en B, zoals hiernaast is weergegeven.De drie vergelijkingsoperaties leveren elk een Booleaanse output op. In deze gevallen is Y allemaal nul, en de lage-orde bit Y is een 0 of 1 die de uitkomst van de vergelijking tussen de 32-bits A en B operanden weergeeft. We kunnen het ALU-ontwerp benaderen door het op te splitsen in subsystemen gewijd aan rekenkundige, vergelijkende, Booleaanse en verschuivingsbewerkingen, zoals hieronder weergegeven:

Het ontwerpen van een complex systeem zoals een ALU kan het beste in fasen worden gedaan, zodat individuele subsystemen één voor één kunnen worden ontworpen en gedebugged. De onderstaande stappen volgen die aanpak voor het implementeren van het ALU-blok diagram dat hierboven getoond wordt. We beginnen met het implementeren van een ALU-raamwerk met dummy modules voor elk van de vier belangrijkste subsystemen (BOOL, ARITH, CMP, en SHIFT); vervolgens implementeren en debuggen we echt werkende versies van elk subsysteem. Om u te helpen dit pad te volgen, geven we afzonderlijke tests voor elk van de vier componentmodules.OPMERKING: de FN-signalen die worden gebruikt om de werking van het ALU-schakelsysteem te controleren, gebruiken een codering die is gekozen om het ontwerp van het ALU-schakelsysteem eenvoudig te maken. Deze codering is niet dezelfde als die welke wordt gebruikt voor het coderen van het 6-bits opcodeveld van Beta-instructies. In Lab 5 bouw je logica (in feite een ROM) die het opcodeveld van een instructie vertaalt in de juiste FN controlebits. Hieronder staan ontwerp notities die aangeven hoe je te werk moet gaan bij het ontwerp voor elk van de submodules. BOOL unit Ontwerp de schakeling om de Booleaanse operaties voor uw ALU uit te voeren en gebruik deze om de jumper en draad te vervangen die de Youtput met massa verbindt.De voorgestelde implementatie gebruikt 32 kopieën van een 4-naar-1-multiplexor (mux4) waarbij BFN de uit te voeren bewerking codeert en A en B aan de selectingangen van de multiplexor worden gehaakt. Deze implementatie kan elk van de 16 2-input Booleaanse functies produceren.

De volgende tabel toont de coderingen voor enkele van de BFN-control signalen die gebruikt worden door de test jig (en in onze typische Betaimplementaties):

AND

XOR

Operation	BFN
1000
OR	1110
0110
“A”	1010

De BOOL-test controleert in feite alle 16 booleaanse bewerkingen op een selectie van argumenten, en zal alle fouten rapporteren die hij vindt.Wanneer uw BOOL schakeling is ingevoerd, voer de test uit door op het groene vinkje te klikken; een simulatie plot venster met de in- en uitgangen zou moeten verschijnen. Jade controleert de resultaten van uw schakeling aan de hand van een lijst met verwachte waarden en meldt de gevonden afwijkingen.

ARITH-eenheidOntwerp een addder/subtractor (ARITH) eenheid die werkt op 32-bits tweevoudige complementingangen en een 32-bits uitgang genereert. Het zal nuttig zijn om drie andere uitgangssignalen te genereren die door de CMP-eenheid kunnen worden gebruikt: Z, dat waar is als de S-uitgangen allemaal nul zijn, V, dat waar is als de opteloperatie overloopt (d.w.z. als het resultaat te groot is om in 32 bits te worden weergegeven), en N, dat waar is als de som negatief is (d.w.z., S = 1).Overflow kan nooit optreden als de twee operanden van de optelling verschillende tekens hebben; als de twee operanden hetzelfde teken hebben, dan kan overflow worden gedetecteerd als het teken van het resultaat verschilt van het teken van de operanden:

\(V = XA_{31}\cdot XB_{31}\overline{S_{31}} + \overline{XA_{31}}{XB_{31}}{31}}Merk op dat deze vergelijking XB gebruikt, dat is het hogere bit van de B operand naar de adder zelf (d.w.z. na de XOR poort – zie het schema hieronder). XA is gewoon A. Het volgende schema is een suggestie voor hoe het ontwerp moet worden uitgevoerd:

AFN wordt op 0 gezet voor een ADD (S = A+B)) en 1 voor eenSUBTRACT (S = A-B\)); A en B zijn de32-bit two’s complement input operands; S is het 32-bit resultaat; Z/V/N zijn de drie conditiecodebits die hierboven zijn beschreven. We gebruiken de “little-endian” bitnummering conventie waarbij bit 31 het meest significante bit is en bit 0 het minst significante bit. We hebben een FA module voorzien voor het invoeren van het gate-level schema voor de volledige adder (zie Opgave 8 van Lab #1) om te gebruiken bij het construeren van de 32-bit ripple carry adder die het hart vormt van de ARITH eenheid. Het AFN ingangssignaal bepaalt of de bewerking een ADD of een SUBTRACT is. Om een SUBTRACT uit te voeren, berekent de schakeling eerst de tweevoudige ontkenning van de B operand door B te inverteren en vervolgens één toe te voegen (wat kan worden gedaan door de carry-in van de 32-bit add op 1 te forceren). Begin met het implementeren van de 32-bit add met behulp van een triple-carry architectuur (je zult dit later in de cursus kunnen verbeteren). Je zult de 32-input NOR poort die nodig is om Z te berekenen moeten construeren met behulp van een boom van kleinere fan-in poorten (de onderdelenbibliotheek heeft alleen poorten met maximaal 4 ingangen). Vergeet niet bij het invoeren van je schakelingen de originele jumpers en draden te verwijderen die de uitgangen met massa verbonden! De moduletest probeert verschillende operanden op te tellen en af te trekken, waarbij je ervoor zorgt dat de uitgangen Z, V en N na elke bewerking correct zijn. CMP eenheidDe ALU biedt drie vergelijkingsoperaties voor de A en B operanden. We kunnen de hierboven ontworpen optel-unit gebruiken om A-B te berekenen en dan naar het resultaat kijken (eigenlijk alleen de Z, V en N conditiecodes) om te bepalen of A=B, A < B of A ≤ B. De vergelijkingsoperaties genereren een 32-bits resultaat waarbij het getal 0 voor fout staat en het getal 1 voor waar.Ontwerp een 32-bit vergelijkingsunit (CMP) die een van de twee constanten (0 of 1) genereert, afhankelijk van de CFN-controlesignalen (gebruikt om de uit te voeren vergelijking te selecteren) en de Z-, V- en N-uitgangen van de adder/subtractor. Het is duidelijk dat de hoogste 31 bits van de uitgang altijd nul zijn. De minst significante bit (LSB) van de uitgang wordt bepaald door de vergelijking die wordt uitgevoerd en de resultaten van de aftrekking die door de opteller/aftrektrekker wordt uitgevoerd:

Vergelijking

Vergelijkingsformule voor LSB	CFN
A = B	LSB = Z(Z)	01
A < B	LSB = \(N \oplus V)	10
A ≤ B	LSB = \(Z + (N \oplus V)	11

Op het niveau van de ALU-module, FN gebruikt om de vergelijkingseenheid aan te sturen, omdat we FN moeten gebruiken om de optel/aftrek eenheid aan te sturen om een aftrekking te forceren.Opmerking over de prestaties: de ingangen Z, V en N in deze schakeling kunnen pas worden berekend door de optel-/trekkeenheid nadat de 32-bit optelling is voltooid. Dit betekent dat ze vrij laat aankomen en dan verdere bewerking in deze module vereisen, waardoor Y pas zeer laat in het spel verschijnt. Je kunt de zaak aanzienlijk versnellen door na te denken over de relatieve timing van Z, V en N en dan je logica zo te ontwerpen dat vertragingspaden met laat binnenkomende signalen worden geminimaliseerd.De module test zorgt ervoor dat het juiste antwoord wordt gegenereerd voor alle mogelijke combinaties van Z, V, N en CFN. SHIFT-eenheidOntwerp een 32-bit shifter die logische linker shift (SHL), logische rechter shift (SHR) en rekenkundige rechter shift (SRA) uitvoert. De A operand levert de te verschuiven gegevens en de lage-orde 5 bits van de B operand worden gebruikt als de verschuivingstelling (d.w.z. van 0 tot 31 bits van de verschuiving). De gewenste operatie wordt als volgt op SFN gecodeerd:

SHL (shift links)

Operation	SFN
00
SHR (shift rechts)	01
SRA (shift rechts met tekenextensie )	11

Met deze codering, SFN is 0 voor een verschuiving naar links en 1 voor een verschuiving naar rechts en SFN regelt de tekenuitbreidingslogica bij een verschuiving naar rechts. Voor SHL en SHR worden 0’s verschoven naar de vrijgekomen bitposities. Voor SRA (“shift right arithmetic”) worden de vrijgekomen bitposities allemaal gevuld met A, het tekenbit van de oorspronkelijke data, zodat het resultaat hetzelfde is als het delen van de oorspronkelijke data door de juiste macht van 2. De eenvoudigste implementatie is om twee shifters te bouwen – een voor het verschuiven naar links en een voor het verschuiven naar rechts – en dan een 2-weg 32-bit multiplexer te gebruiken om het juiste antwoord als uitgang van de module te selecteren. Het is gemakkelijk om een shifter te bouwen nadat is opgevallen dat een multi-bit verschuiving kan worden bereikt door cascade verschuivingen met verschillende machten van 2. Bijvoorbeeld, een 13-bit verschuiving kan worden uitgevoerd door een verschuiving van 8, gevolgd door een verschuiving van 4, gevolgd door een verschuiving van 1. De shifter is dus gewoon een cascade van multiplexers die elk worden aangestuurd door één bit van de verschuivingstelling. Het schema hieronder toont een mogelijke implementatie van de linkse verschuivingslogica; de rechtse verschuivingslogica is vergelijkbaar met de kleine extra complicatie van het moeten verschuiven naar ofwel 0 (d.w.z. “gnd”) of A, afhankelijk van de waarde vanSFN. Een andere benadering die poorten bespaart is de linkshift-logica te gebruiken voor zowel links- als rechtsverschuivingen, maar voor rechtsverschuivingen de bits van de A operand om te keren op de weg naar binnen en de bits van de uitgang om te keren op de weg naar buiten.

De moduletest controleert of alle drie de soorten shifts correct werken. Laatste testsWanneer u klaar bent met het ontwerp van de vier submodules, selecteert u de ALU-module en voert u de test uit. Dit loopt elk van de testpakketten die je hebt gebruikt om de component subschakelingen te debuggen, dus tenzij er een onvoorziene interactie is tussen je blokken zul je waarschijnlijk slagen voor de test. Als deze test succesvol is afgerond, zal het systeem uw ontwerp als compleet markeren. Opgave 2. Testen van de ALUIn het ontwerpprobleem van dit practicum (zie boven), bouw je een 32-bit rekenkundige en logische eenheid (ALU) die rekenkundige en logische bewerkingen uitvoert op 32-bit operanden, met als resultaat een 32-bit resultaat. Je zult deze schakeling gebruiken in het ontwerp van de Beta later dit semester. Misschien wil je eerst aan het ontwerpprobleem werken en dan terugkomen op dit probleem. De test voor dit lab controleert je ALU-schakeling door 186 verschillende sets van invoerwaarden toe te passen. Geen enkele ontwerper die ik ken vindt testen leuk – de schakeling ontwerpen lijkt zoveel interessanter dan kijken of hij werkt. Maar een buggy ontwerp is ook niet leuk! Bedenk dat een goed ontwerper niet alleen weet hoe hij goede ontwerpen moet maken, maar ook daadwerkelijk goede ontwerpen maakt, en dat betekent dat het ontwerp getest moet worden om er zeker van te zijn dat het doet wat jij zegt dat het doet.Een voor de hand liggende manier om een combinatorische schakeling te testen is om alle mogelijke combinaties van ingangen te proberen, waarbij gecontroleerd wordt of de uitgangswaarden juist zijn na toepassing van elke ingangscombinatie. Dit type uitputtende test bewijst de juiste werking door de waarheidstabel van de combinator op te sommen. Dit is een werkbare strategie voor schakelingen met weinig ingangen, maar wordt al snel onpraktisch voor schakelingen met veel ingangen. Door gebruik te maken van informatie over hoe de schakeling is opgebouwd, kunnen we het aantal ingangscombinaties dat nodig is om de schakeling te testen sterk verminderen.De ripple-carry-adderarchitectuur die in de ontwerpopgave wordt voorgesteld, maakt gebruik van 32 kopieën van de volledige optelmodule om een 32-bits optelmodule te maken.Elke volledige optelmodule heeft 3 ingangen (A, B, CI) en twee uitgangen (S, CO):

1. Een enkele testvector voor de volledige adder bestaat uit 3 ingangswaarden (een voor A, B en CI) en 2 uitgangswaarden (S en CO). Om een test uit te voeren worden de ingangswaarden van de huidige testvector toegepast op het te testen apparaat en vervolgens worden de werkelijke uitgangswaarden vergeleken met de door de testvector genoemde verwachte waarden. Dit proces wordt herhaald totdat alle testvectoren zijn gebruikt. Ervan uitgaande dat we niets weten over de interne schakeling van de volledige adder, hoeveel testvectoren zouden we nodig hebben om de functionaliteit ervan uitputtend te testen? Aantal testvectoren om een volledige opteller uitputtend te testen?
2. Zie eens een 32-bit opteller met 64 ingangen (twee 32-bit input operands, waarbij CIN aan massa is gebonden zoals in onderstaand schema) en 32 uitgangen (het 32-bit resultaat). Veronderstel dat we niets weten over de interne schakeling en dus niet kunnen uitsluiten dat die voor een bepaalde combinatie van ingangen een verkeerd antwoord kan geven. Met andere woorden, het feit dat de opteller het juiste antwoord kreeg voor 2 + 3 laat ons niet toe conclusies te trekken over welk antwoord hij zou krijgen voor 2 + 7. Als we elke 100ns een testvector zouden kunnen toepassen, hoe lang zou het dan duren om de adder volledig te testen? Tijd om 32-bit adder uitputtend te testen? (in jaren)
3. Het is duidelijk dat het testen van een 32-bit adder door alle combinaties van invoerwaarden uit te proberen geen goed plan is! Hieronder zie je een schema voor een 32-bit ripple-carry-adder. Behalve de carry-in van het bit rechts, werkt elk bit van de opteller onafhankelijk. We kunnen deze observatie gebruiken om de adder bit-voor-bit te testen en met een beetje nadenken kunnen we in feite veel van deze tests parallel uitvoeren. In dit geval zegt het feit dat de opteller het juiste antwoord gaf voor 2 + 3 ons eigenlijk veel over het antwoord dat hij zal krijgen voor 2 + 7. Aangezien de berekening van de bits 0 en 1 van de adder in beide gevallen hetzelfde is, zullen, als het antwoord voor 2 + 3 juist is, de twee bits van de lage orde van het antwoord voor 2 + 7 ook juist zijn. Dus ons plan voor het testen van de ripple-carry adder is om elke volledige adder onafhankelijk te testen. Bij het testen van bit N kunnen we A en B direct vanuit de testvector instellen. Het kost wat meer werk om CI op een bepaalde waarde in te stellen, maar we kunnen het doen met de juiste keuzes voor A en B. Als we CI op 0 willen instellen, op welke waarden moeten A en B dan worden ingesteld? Als we CI op 1 willen zetten? Neem aan dat we niets mogen aannemen over de waarde van CI. Waarden van A en B om C=0 te maken? A=0, B=0 A=1, B=0 A=0, B=1 A=1, B=1 Waarden van A en B om C=1 te maken? A=0, B=0 A=1, B=0 A=0, B=1 A=1, B=1 Met deze strategie kunnen we de even bits van de adder parallel testen met een set testvectoren en de oneven bits van de adder parallel testen met een andere set testvectoren. Hier is een set van 10 testvectoren die alle combinaties van invoerwaarden voor elke FA in een 32-bit ripple-carry adder zou moeten testen:
   A=1, B=0, CI=0

   bits 0, 2, …	bits 1, 3, …	A	B
   A=0, B=0, CI=0	A=0, B=0, CI=0	0x00000000	0x00000000
   A=0, B=0, CI=0	0x55555555	0x000000
   A=0, B=1, CI=0	A=0, B=0, CI=0	0x00000000	0x555555
   A=1, B=1, CI=0	A=0, B=0, CI=1	0x555555	0x55555555
   A=0, B=0, CI=0	A=1, B=0, CI=0	0xAAAAAA	0x000000	A=0, B=0, CI=0	A=0, B=1, CI=0	0x00000000	0xAAAA	A=0, B=0, CI=1	A=1, B=1, CI=0	0xAAAA	0xAAAA	0xAAAA	A=1, B=0, CI=1	A=1, B=0, CI=1	0xFFFFFF	0x00000001
   A=0, B=1, CI=1	A=0, B=1, CI=1	0x0000000101	0xFFFFFF
   A=1, B=1, CI=1	A=1, B=1, CI=1	0xFFFFFF	0xFFFFFF

4. Drie van de ingangen van de vergelijker (Z, V en N) zijn afkomstig van de adder/subtractor die in subtractmodus werkt en A-B berekent:
Z = 1 als A-B 0 is N = 1 als A-B negatief is (OUT = 1) V = 1 als er een overflow is geweest. De ALU, die alleen een adder heeft, berekent A-B als A+(-B) = A+(~B)+1. Stel XB = ~B, het bit-wise complement van B. Er is sprake van een overflow als het teken van het resultaat (OUT) afwijkt van het teken van de operanden van de opteller (A, XB). Merk op dat als de tekens van A en XB verschillen, de optelling geen overflow kan veroorzaken. Om de vergelijkingseenheid te testen, moeten we operanden voor de adder/subtractor kiezen die alle mogelijke combinaties van Z, V en N genereren. Het is gemakkelijk te zien dat elke combinatie met Z = 1 en N = 1 niet mogelijk is (de uitgang van de adder kan niet tegelijkertijd negatief en nul zijn!) Het blijkt ook dat combinaties met Z = 1 en V = 1 niet door een aftrekbewerking kunnen worden verkregen. Kies voor elk van de hieronder getoonde combinaties van Z, V en N de aftrekbewerking die de gespecificeerde combinatie van toestandscodes zal opleveren. Aftrekken die Z=0, V=0, N=0 oplevert? 0x12345678 – 0x12345678 0x7FFFFFFF – 0xFFFFFFFF 0x00000005 – 0xDEADBEEF 0xDEADBEEF – 0x00000005 0x80000000 – 0x00000001 Aftrekking die Z=1, V=0, N=0 oplevert? 0x12345678 – 0x12345678 0x7FFFFFFF – 0xFFFFFFFF 0x00000005 – 0xDEADBEEF 0xDEADBEEF – 0x00000005 0x80000000 – 0x00000001 Aftrekking die Z=0, V=1, N=0 oplevert? 0x12345678 – 0x12345678 0x7FFFFFFF – 0xFFFFFFFF 0x00000005 – 0xDEADBEEF 0xDEADBEEF – 0x00000005 0x80000000 – 0x00000001 Aftrekking die Z=0, V=0, N=1 oplevert? 0x12345678 – 0x12345678 0x7FFFFFFF – 0xFFFFFFFF 0x00000005 – 0xDEADBEEF 0xDEADBEEF – 0x00000005 0x80000000 – 0x00000001 Aftrekking die Z=0, V=1, N=1 oplevert? 0x12345678 – 0x12345678 0x7FFFFFFF – 0xFFFFFFFF 0x00000005 – 0xDEADBEEF 0xDEADBEEF – 0x00000005 0x80000000 – 0x00000001 Opgave 3. De veelzijdige BOOL eenheid

0

Bi	Ai	Yi
0	0	d
1	c
1	0	b
1	1	a

Zoals we zagen in de instructies voor de ALU,worden de bitwise Booleaanse operaties gespecificeerd door FN=10. In dit geval worden de resterende FN-bits abcd genomen als punten in de waarheidstabel die beschrijft hoe elk bit van Y wordt bepaald door de overeenkomstige bits van A en B, zoals hiernaast is weergegeven. Bepaal voor elk van de onderstaande Booleaanse bewerkingen de instellingen voor FN zodat de Bool-eenheid de gewenste bewerking zal berekenen. AND(A,B): FN= 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 OR(A,B): FN= 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 XOR(A,B): FN= 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 NAND(A,B): FN= 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 NOR(A,B): FN= 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 XNOR(A,B): FN= 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 A: FN= 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 B: FN= 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111