Unterlagen zu Versuch 3

IL
IS
VS
PRAKTIKUM ZUR
VORLESUNG
Rechnergesteuerte Systeme 2
VERSUCH 3
ADDITIONSSCHALTUNGEN UND ALU
Name: Matrikelnummer:
Vorname: Gruppennummer:
Betreuer: Datum:
Universität Duisburg-Essen
Fak. 5, Abt. IIMT, Institut für
Informationstechnik (IT)
Verteilte Systeme (VS)
© Dr.-Ing. Heinz-Dieter Hümmer
Universität Duisburg-Essen
Fak. 5, IIMT, IT/VS

Praktikum zu RgS 2 Versuch 3: ADDITIONSSCHALTUNGEN UND ALU
Hinweise
• Arbeiten Sie den anliegenden Vorbereitungstext sorgfältig durch.
• Lösen Sie die im Vorbereitungstext gestellten Aufgaben und bringen Sie Ihre Ergebnisse zum Versuchstermin
mit.
• Beantworten Sie zum Antestat die folgenden Fragen.
Vorbereitende Fragen
1. Geben Sie die logischen Gleichungen eines Volladdierers wieder. Minimieren Sie die Gleichungen
möglichst unter Zuhilfenahme der Antivalenzverknüpfung (xor)!
2. Nach welcher Zeit kann bei einem Volladdierer wie in Abb. 1 von einem stabilen Ergebnis ausgegangen
werden, wenn alle Gatter die gleiche Verzögerung T besitzen?
3. Warum wurden in der Simulation unter 2.2.1 die binären Zahlen „0001“ und „1111“ an die Eingänge
angelegt?
4. Erklären Sie in einem kurzen Satz worin der prinzipielle Unterschied in der Übertragslogik zwischen
einem Ripple-Carry-Addierer und einem Carry-Look-Ahead-Addierer liegt.
5. Führen Sie im 8 bit Zweierkomplement folgende Operationen schrittweise durch: 2 – 3 ; 5 - 2
6. Welche Dezimalzahlen stellen die untere bzw. obere Grenze im 8 bit Zweierkomplement dar?
7. Vervollständigen Sie folgende for-Schleife zur Realisierung eines 8-bit breiten Ripple-Carry-Addierers
(ohne Betrachtung der Zeitverzögerungen):
for ... loop
...
end loop;
Verwenden Sie dabei folgende Variablen:
a,b : std_logic_vector(8 downto 0); --Operanden
e : std_logic_vector(8 downto 0); --Ergebnis
c : std_logic_vector; --carry
Inhalt
1 Einleitung ..............................................................................................................................3
2 Additionsschaltungen............................................................................................................3
2.1 Volladdierer.....................................................................................................................3
2.2 Ripple-Carry-Addierer .....................................................................................................4
2.2.1 Simulationsergebnis..................................................................................................5
2.3 Carry-Look-Ahead Addierer ............................................................................................5
2.4 Aufgabe 1 .......................................................................................................................6
3 Arithmetisch-logische Einheit(ALU) eines Prozessors ..........................................................7
3.1 Der Signaltyp std_logic .................................................................................................7
3.2 Schnittstelle und Verhalten der ALU ...............................................................................7
3.3 Aufgabe 2 .......................................................................................................................9
Entwurfsempfehlungen .........................................................................................................9
Universität Duisburg-Essen; Fakultät 5; Abt. IIMT; Inst. Informationstechnik (IT), Verteilte Systeme (VS) Seite 2

Praktikum zu RgS 2 Versuch 3: ADDITIONSSCHALTUNGEN UND ALU
1 Einleitung
In diesem Versuch sollen einleitend zwei Varianten eines mehrstelligen, binären Addieres vorgestellt
werden; daran anschließend wird auf den Entwurf einer kompletten arithmetischen logischen Einheit
(ALU) eingegangen.
2 Additionsschaltungen
2.1 Volladdierer
Wie schon aus den vorherigen Versuchen bekannt ist, kann ein Volladdierer aus zwei Halbaddieren aufgebaut
werden; zur Erinnerung ist in Abbildung Abb. 1 das Schaltbild eines solchen Konstruktes dargestellt.
ai
bi
ci
Halbaddierer 1
=1
&
Halbaddierer 2
Abb. 1: Schaltbild eines Volladdierers
Dem in Abb. 1 dargestellten Volladdierer entspricht das folgende VHDL-Modell (Datenfluss), das auf die
einzelnen logischen Gleichungen aufbaut. Aufgrund der zugewiesenen Gatterverzögerungszeit – die
Zeitkonstante totzeit – kommt dieses Modell den realen Komponenten sehr nahe.
entity volladdierer is
port(a,b,c_i: in bit; s,c_o: out bit);
end volladdierer;
architecture verhalten of volladdierer is
constant totzeit: time := 10 ns; --Zeitkonstante
signal x,y,z: bit;
begin
s

Praktikum zu RgS 2 Versuch 3: ADDITIONSSCHALTUNGEN UND ALU
2.2 Ripple-Carry-Addierer
Durch die Verkettung von mehreren Volladdierern entsteht ein mehrstelliger Addierer: ein sog. Ripple-
Carry-Addierer. Dieser erfüllt zwar die mathematischen Anforderungen, ist aus technischer Sicht jedoch
keine befriedigende Lösung aufgrund der "seriellen" Fortpflanzung (ripple, dahinplätschern) des Carry-
Bits. Durch diese serielle Verkettung der Stufen entsteht ein langer Signal-Pfad und bedenkt man, dass
jedes Gatter eine „Gatterverzögerung“ hat – auf die hier nicht weiter eingegangen wird –, so wird deutlich,
dass diese Verschaltung bei großen Wortlängen ungünstig ist. Anhand der nächsten VHDL Modelle
soll dieses Verhalten verdeutlicht werden. Hier wurde mit einzelnen Volladdierern ein 4-bit breiter Addierer
konstruiert, der wie in der folgenden graphischen Darstellung Abb. 2 verschaltet ist.
cin
cout
c4
Σ
a3
s3
b3
cin
cout
Abb. 2: Schaltbild des Ripple-Carry-Addierers
Um einen mehrstelligen (hier vierstellig) Addierer im strukturellen Entwurfstil zu kreieren, setze man den
Volladdierer als component ein. Jede dieser mehrfach verwendeten Komponente erhält einen eigenen
Namen (Instanziierung der Komponente). Die Verknüpfung der Ein- und Ausgänge der Instanzen mit
den lokal deklarierten Signalen, die sogenannte Netzliste, ist im folgenden Programmcode aufgeführt.
entity rc_addierer is
port(al,bl: in bit_vector (3 downto 0);
sl: out bit_vector (3 downto 0);
c_ol: out bit);
end rc_addierer;
architecture struktur of rc_addierer is
signal x0, x1, x2, x3: bit:='0';
a2 b2
component volladdierer is
port(a,b,c_i: in bit; s,c_o: out bit);
end component;
-- Instanziierung der Komponenten
for VA0: volladdierer use entity mywork.volladdierer(verhalten);
for VA1: volladdierer use entity mywork.volladdierer(verhalten);
for VA2: volladdierer use entity mywork.volladdierer(verhalten);
for VA3: volladdierer use entity mywork.volladdierer(verhalten);
Σ
begin -- Netzliste
VA0: volladdierer port map(a=>al(0),b=>bl(0),c_i=>x0,s=>sl(0),c_o=>x1);
VA1: volladdierer port map(a=>al(1),b=>bl(1),c_i=>x1,s=>sl(1),c_o=>x2);
VA2: volladdierer port map(a=>al(2),b=>bl(2),c_i=>x2,s=>sl(2),c_o=>x3);
VA3: volladdierer port map(a=>al(3),b=>bl(3),c_i=>x3,s=>sl(3),c_o=>c_ol);
end struktur;
s2
a1 b1
Universität Duisburg-Essen; Fakultät 5; Abt. IIMT; Inst. Informationstechnik (IT), Verteilte Systeme (VS) Seite 4
cin
cout
Σ
s1
c0 = 0
cin
cout
Σ
a0 b0
s0

Praktikum zu RgS 2 Versuch 3: ADDITIONSSCHALTUNGEN UND ALU
2.2.1 Simulationsergebnis
Werden nun zwei 4-bit breite Bitmuster - "0001" und "1111" - an die Eingänge al und bl gelegt - sie
waren zuvor mit dem Muster "0000" belegt -, so ergibt sich folgendes Diagramm (Abb. 3):
Abb. 3: Graphische Darstellung der beschriebenen Simulation.
Hier wurde die Bitmuster so gewählt, dass die maximale Verzögerungszeit von 80 ns deutlich zu sehen
ist. Erklären lässt sich das Verhalten wie folgt: Im ersten Volladdierer, ist das Carry-Ausgangssignal
nach 20 ns stabil, da an dessem Carry-Eingang ständig eine Null anliegt und das AND-Gatter des zweiten
Halbaddierers (siehe Abb.1) nie eine Eins am Ausgang führen kann. Die restliche Verzögerungszeit
ergibt sich aus der Summe aller Verzögerungszeiten der Gatter im Carry-Bit Signalpfad, also
3*2*totzeit. Summiert man sie auf, ergeben sich die 80 ns Gesamtverzögerungszeit.
2.3 Carry-Look-Ahead Addierer
Die Problematik der großen Durchlaufzeiten läßt sich durch anders konzipierte Addierer umgehen. Als
ein Beispiel soll hier ein Carry-Look-Ahead Addierer vorgestellt werden. Dieser besitzt eine separate, an
die Wortbreite angepasste Logik, wie in der nächsten Abbildung Abb. 4 zu sehen ist.
c3
>1
a2 b2
&
g2
=1
p2
=1
s2
a1 b1
&
Abb. 4: Schaltbild eines 3-bit breiten Carry-Look-Ahead Addierers.
Universität Duisburg-Essen; Fakultät 5; Abt. IIMT; Inst. Informationstechnik (IT), Verteilte Systeme (VS) Seite 5
=1
=1
c2 g1p1c1
s1
>1 >1
& & &
& &
&
a0 b0
&
g0
=1
p0
=1
s0
c0
c0=0

Praktikum zu RgS 2 Versuch 3: ADDITIONSSCHALTUNGEN UND ALU
Dargestellt wird ein 3-bit breiter Carry-Look-Ahead Addierer (CLA): Die jeweils identischen Module haben
den Übertragseingang c, die Additionseingänge a und b und liefern mit dem Signal s das Ergebnis.
Abweichend vom vorherigen Modell besitzen sie jedoch noch zwei weitere Ausgänge, nämlich
p: Propagate und
g: Generate.
Diese tragen die notwendige Information für den Übertrag: g signalisiert, ob im Modul ein Übertrag erzeugt
wird und p, ob ein Carry-Bit des vorherigen Moduls an das nächste Modul übertragen wird. Die
Ausgangsignale sind definiert durch:
g(i) := a(i) and b(i)
p(i) := a(i) xor b(i)
s(i) := p(i) xor c(i)
Das jeweilige Carry-Bit c(i+1) als Stellenübertrag des Moduls an der Stelle i mit i > 0 errechnet sich zu:
c(i+1) := g(i) or (p(i) and c(i))
Um die Verzögerung durch die rekursive Form der obigen Gleichung zu vermeiden, wird für jeden Übertragseingang
eine eigene Logik aufgebaut (siehe Abb. 4). Dieser parallele, zweistufige Aufbau von UND-
ODER Verknüpfungen ermöglicht eine gleich bleibende Verzögerung, unabhängig von der Wortbreite,
jedoch erkauft durch einen größeren Schaltungsaufwand. Die einzelnen Übertragsgleichungen der jeweiligen
Positionen zeigt das auf und sie werden wie folgt ausgedrückt:
c(0) := 0 -- festgelegt
c(1) := g(0) -- schon gekürzt
c(2) := g(1) or (p(1) and g(0))
c(3) := g(2) or (p(2) and g(1)) or (p(2) and p(1) and g(0))
2.4 Aufgabe 1
Entwerfen Sie einen 4-bit breiten CLA mit einer generellen Gatterverzögerungszeit von 10 ns und vergleichen
Sie die maximale Antwortzeit des CLA mit der des Ripple-Carry-Addierers anhand einer
Testbench.
Universität Duisburg-Essen; Fakultät 5; Abt. IIMT; Inst. Informationstechnik (IT), Verteilte Systeme (VS) Seite 6

Praktikum zu RgS 2 Versuch 3: ADDITIONSSCHALTUNGEN UND ALU
3 Arithmetisch-logische Einheit(ALU) eines Prozessors
Das vorrangige Thema der kommenden Versuche dieses Praktikums ist der Entwurf eines kleinen Prozessors.
Die grundlegende Architektur eines Prozessors, die Von-Neumann-Architektur, wird dabei als
bekannt vorausgesetzt und daher in den Versuchsanleitungen nicht weiter theoretisch betrachtet. Der
Entwurf des Prozessors soll in kleinen Schritten erfolgen und daher werden in den einzelnen Versuchen
wesentliche Bestandteile des Prozessors mit wohldefinierten Schnittstellen vorgestellt und deren Realisierung
als VHDL-Modell zu Aufgabe gestellt. Diese hier mehr pragmatische Vorgehensweise verzichtet
zunächst bewusst darauf, sich auf ein starres Gesamtkonzept (Maschinentyp, Befehlssatz u.s.w.) für
den Prozessor fest zu legen. Statt dessen wird mit dem Entwurf der ALU, der arithmetisch-logischen
Einheit des Prozessors, begonnen.
3.1 Der Signaltyp std_logic
Bevor auf die Einzelheiten der ALU eingegangen wird, soll zunächst ein neuer Datentyp vorgestellt werden,
der für möglichst alle Signale und Variablen in allen zum Prozessorentwurf gehörenden VHDL-
Modellen zu verwenden ist:
std_logic bzw. std_logic_vector aus dem Package ieee.std_logic_1164 (IEEE Standard 1164-
1993).
Im Gegensatz zum bisher verwendeten Typ bit mit den Logikwerten ’0’ und ’1’ erlaubt das Package
std_logic die Modellierung von weiteren, für die reale Hardware typischen Logikwerten (sog.9-wertiges
Logikmodell), die in der folgenden Tabelle (Tabelle 1) aufgelistet sind.
Wert Bedeutung Verwendung
'U' Nicht initialisiert Nicht initialisiertes Signal im Simulator „unknown“
'X' Undefiniert Simulator erkennt mehr als einen aktiven Signaltreiber (Buskonflikt)
'0' Starke logische '0' Entspricht '0' eines bit-Signals
'1' Starke logische '1' Entspricht '1' eines bit-Signals
'Z' Hochohmig 'Z' Tri-state Ausgang
'W' Schwach unbekannt Simulator erkennt Buskonflikt zwischen 'L' und 'H' „weak“
'L' Schwache logische '0' Ausgang mit Pull-Down Widerstand (Open Source)
'H' Schwache logische '1' Ausgang mit Pull-Up Widerstand (Open Drain)
'-' Don’t Care Logikzustand bedeutungslos; kann zur Minimierung verwendet werden
Tabelle 1: Wertevorrat von std_logic
Signalwerte wie 'X' und 'Z' werden erst im Zusammenhang mit bidirektionalen Bussen interessant,
wenn Fälle behandelt werden, in denen z.B. mehrere Treiber (Signalquellen) auf den Signalbus schreibend
zugreifen. In solchen Fällen müssen Buskonflikte erkannt und aufgelöst werden. Im Zusammenhang
mit der ALU entstehen solche Schwierigkeiten nicht, aber trotzdem empfiehlt es sich auch beim
Entwurf der ALU das Package std_logic zu verwenden, um im gesamten Prozessorentwurf einen
durchgehend direkt kompatiblen Signaltyp zu haben und auf Konvertierungsfunktionen verzichten zu
können.
3.2 Schnittstelle und Verhalten der ALU
Die ALU eines Prozessors stellt die Recheneinheit
für arithmetische und logische Operationen dar. Sie
erzeugt aus den beiden gegebenen Operanden A
und B durch rein kombinatorische Logik das
Operationsergebnis E (siehe Abb. 5). Über die
Steuerleitungen S werden die einzelnen Funktionen
der ALU ausgewählt. Außer dem Ergebnis E liefert
die ALU sog. Statussignale (Flags), die einige
Eigenschaften des Operationsergebnisses
anzeigen.
Universität Duisburg-Essen; Fakultät 5; Abt. IIMT; Inst. Informationstechnik (IT), Verteilte Systeme (VS) Seite 7
S
A B
ALU
E
Abb. 5
Statussignale

Praktikum zu RgS 2 Versuch 3: ADDITIONSSCHALTUNGEN UND ALU
Folgende Rahmendaten seien nun zur Realisierung einer einfachen ALU im Hinblick auf die Aufgabenstellung
dieses Versuches gegeben:
Die Breite der Datenbusse (jeweils A, B und E) sei 8 bit.
Die Breite der Steuerbusses (S) sei 3 bit.
Die Anzahl der zur ALU gehörenden Steuerleitungen (hier 3) verrät, wie viele Operationen die ALU maximal
ausführen kann. Folgende acht Operationen (Tabelle 2) seien nun gefordert:
Nr. Operation Mnemonic Codierung Kurzerläuterung Statussignale
(Verwendete Operanden) C Z
0 Reserviert 000
offen lassen für evtl.
spätere Verwendung
0 *
1 Addition ADD 001 A + B → E * *
2 Subtraktion SUB 010 A – B → E * *
3 Bitweise Konjunktion AND 011 A ∧ B → E 0 *
4 Bitweise Disjunktion OR 100 A ∨ B → E 0 *
5 Bitweise Negation NOT 101 ¬A → E 0 *
6 Logisches Links-Schieben SLL 110 A > 1 → E
siehe Erläuterung unten
* *
Tabelle 2: ALU-Operationen
Die in der Spalte „Codierung“ stehenden Werte werden über die Steuerleitungen an die ALU gelegt, um
die entsprechende Operation auszuwählen. Die am weitesten rechts stehende Spalte zeigt, welche Statussignale
bei den jeweiligen Operationen gesetzt werden müssen. Die Zeichen in dieser Spalte haben
folgende Bedeutung:
C : Übertrag (carry), der z.B. bei einer Addition über die höchstwertige Stelle hinaus entstehen
kann
Z : Zero Flag, wird auf ’1’ gesetzt, falls das Ergebnis gleich Null ist
0 : Flag löschen
* : Flag gemäß dem Ergebnis setzen
Die folgenden Abbildungen machen die Arbeitsweise der Schiebe-Operationen deutlich:
SLL : shift left logically: Das Datenwort wird um eine Stelle in Richtung höherer Wertigkeit
verschoben. Danach wird in die niedrigstwertige Stelle (LSB: Least Significant Bit) eine
'0’ geschrieben. Das höchstwertige Bit (MSB: Most Significant Bit) wird als Übertrag (C:
Carry) festgehalten.
C
MSB ... LSB '0’
SRA : shift right arithmetically: Das Datenworte wird um eine Stelle in Richtung niedrigerer
Wertigkeit verschoben. Danach wird die niedrigstwertige Stelle (LSB) als Carry ausgegeben.
Das höchstwertige Bit (MSB) behält seinen Wert, damit das Vorzeichen erhalten
bleibt.
C
MSB ... LSB
Bei den Operationen Addition und Subtraktion soll die ALU Daten in der 8-bit Zweierkomplement-
Darstellung verarbeiten.
Universität Duisburg-Essen; Fakultät 5; Abt. IIMT; Inst. Informationstechnik (IT), Verteilte Systeme (VS) Seite 8

Praktikum zu RgS 2 Versuch 3: ADDITIONSSCHALTUNGEN UND ALU
3.3 Aufgabe 2
Erstellen Sie einen VHDL-Modellentwurf der ALU, der die oben beschriebenen Spezifikationen erfüllt.
Die Schnittstelle der ALU sei durch die Tabelle 3 festgelegt. Überprüfen Sie anschließend Ihr ALU-
Modell anhand einer Testbench.
Anschluss[Breite] Richtung Typ
s[3] Eingang std_logic_vector
a[8], b[8] Eingang std_logic_vector
e[8] Ausgang std_logic_vector
cflg, zflg Ausgang std_logic
Tabelle 3: Schnittstelle der ALU
Als Hilfestellung zur Verhaltensbeschreibung der ALU seien folgende Empfehlungen gegeben:
Entwurfsempfehlungen
• Zur Verwendung von std_logic bzw. std_logic_vector und zur eventuellen Nutzung der
arithmetischen Operatoren sind folgende Zeilen vor der betreffenden entity zu platzieren:
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
• Zeitverzögerungen brauchen nicht modelliert zu werden.
• Als Orientierungshilfe zur Erstellung der Architektur sei folgende Vorlage gegeben:
architecture arch of alu is
begin
operate_alu: process(s, a, b) is
subtype vectorType is std_logic_vector(7 downto 0);
variable evar : vectorType; --temporäre Variable
variable carry : std_logic;
procedure add(x,y :in vectorType; sum :out vectorType; c_out :out std_logic) is
variable c : std_logic := '0'; --temporäre Variable,
variable res : vectorType := (others => '0'); --mit Initialisierung
begin
...
sum := res;
c_out := c;
end add;
begin
evar := x"00"; --Initialisierung im Hex-Format, z.B. x"f2" entspricht "11110010"
...
case s is --Verzweigung in die verschiedenen arithm. und log. Operationen
when "001" => --add
add(a,b,evar,carry); --Aufruf der Prozedur mit Parametern
when "010" => --sub
...
when "011" => --and
evar := a and b;
...
when others => null;
end case;
...
e