Kap.2 Befehlsschnittstelle

Kap.2
Befehlsschnittstelle
Prozessoren,
externe Sicht
RA
z
z
z
z
z
z
Überblick
Einleitung
Befehlsschnittstelle
Mikroarchitektur
Speicherarchitektur
Ein-/Ausgabe
Multiprozessorsysteme, ...
CS - RA - SS01
Kap. 2.1
2.1/2
von Neumann-Architektur
Speichereinheit
CPU
RAM/ROM
Steuerbus
Adressbus
Datenbus
CS - RA - SS01
Ein-/Ausgabeeinheit
Kap. 2.1
2.1/3
2 Befehlsschnittstelle
z
z
z
z
z
z
2.1 elementare Datentypen, Operationen
2.2 logische Speicherorganisation
2.3 Maschinenbefehlssatz
2.4 Klassifikation von Befehlssätzen
2.5 Unterbrechungen
2.6 Prozesse
CS - RA - SS01
Kap. 2.1
2.1/4
2.1 Elementare Datentypen,
Operationen
z Bitvektoren
z Natürliche Zahlen, ganze Zahlen
z Gleitkommazahlen
CS - RA - SS01
Kap. 2.1
2.1/5
2.1.1 Bitvektoren,
natürliche Zahlen,
ganze Zahlen
Bitvektoren
z Befehlssätze unterstützen Operationen auf
auf Bitvektoren begrenzter Länge
y Schiebeoperationen
y Test Bit i, Set Bit i, Clear Bit i,
Kopieroperationen, Mustersuche
CS - RA - SS01
Kap. 2.1
2.1/7
Schiebeoperationen
z Verschieben eines Operanden um k
Bitstellen
z Man unterscheidet (gemäß Behandlung
der Datenformatgrenzen)
y logisches Schieben
y arithmetisches Schieben
CS - RA - SS01
Kap. 2.1
2.1/8
z srl/sll (shift right/left logical)
y Verschieben um k Stellen
y Nachziehen von Nullen
z sra/sla (shift right/left arithmetic)
y Verschieben um k Stellen
y sra zieht von links das Bit mit höchster
Wertigkeit nach
y sla behält Vorzeichen bei.
k
k
y sra=Div durch 2 , sla=Mult mit 2
y overflow-Bit muß bei sla geeignet gesetzt
werden
CS - RA - SS01
Kap. 2.1
2.1/9
Schieben um 1 Bit
z
srl1 ( an −1 ,..., a0 ) = (0, an −1 ,..., a1 )
z
sll1 ( an −1 ,..., a0 ) = ( an −2 ,..., a0 ,0)
z sra1 ( an −1 ,..., a0 )
= ( an −1 , an −1 ,..., a1 )
z sla1 ( an −1 ,..., a0 )
= ( an −1 , an −3 ..., a0 ,0)
CS - RA - SS01
Kap. 2.1
2.1/10
Arithmetisches Schieben um 1 Bit
z sra1 ( an −1 ,..., a0 ) = ( an −1 , an −1 ,..., a1 )
z Es gilt:
[ sra1 ( an −1 ,..., a0 )]2 = [an−1 ,..., a0 ]2 / 2
z sla1 ( a n −1 ,..., a0 ) = ( an −1 , an −3 ..., a0 ,0)
z Bei sla muß gegebenfalls ein overflow-Flag im
Statusregister des Prozessors gesetzt werden.
(Nebenbem.: Arithmetische Operationen führen zu
Setzen bzw. Rücksetzen von Statusbits in einem
Statusregister.
Bsp.: overflow flag, carry flag, zero flag, sign flag)
CS - RA - SS01
Kap. 2.1
2.1/11
Arithmetisches Schieben um 1 Bit
z sla1 (a n −1 ,..., a0 ) = ( a n −1 , an − 3 ..., a0 ,0)
z Lemma:
y Es gilt: [ sla1 (an−1 ,..., a0 )]2 = 2 ⋅ [an−1 ,..., a0 ]2
falls an −1 = an −2 .
y Bei sla1 muß overflow-Flag gesetzt werden, genau
dann wenn an −1 ≠ an − 2 .
y Es gilt:
[sla1 (an −1 ,..., a0 )]2 = (2 ⋅ [an−1 ,..., a0 ]2 ) mod 2 n−1
falls ( an−1 ,..., a0 ) ≠ (1,1,0,...,0), (1,0,...,0)
n−1
−
2
(Sonderfall, da
noch im darstellbaren
Zahlenbereich liegt.)
CS - RA - SS01
Kap. 2.1
2.1/12
Fragen zur internen Sicht
z Wie kann man das durch HW realisieren?
z 1-bit Shift --> k-bit Shift ?
y k-bit Shift durch Folge von k 1-bit Shifts
y „Barrel-Shifter“ zum „direkten“ Shiften um k
Bits
CS - RA - SS01
Kap. 2.1
2.1/13
Barrel-Shifter für logischen Linksshift
z Gesucht: Realisierung der Funktion
shift : B n + k → B n , ( an −1 ,..., a0 , wk −1 ,..., w0 ) a (bn −1 ,..., b0 )
wobei sich (bn−1 ,..., b0 ) aus ( an−1 ,..., a0 ) ergibt durch
< wk −1 ,..., w0 > 2-fachen logischen Linksshift (n = 2k ).
k −1
i
z Idee: < wk −1 ,..., w0 > 2 = ∑i = 0 wi 2
Zerlege in Folge von k=log n „potentiellen Shifts“.
y Falls wi = 1 , shifte in Schritt i um 2i Bit
y Falls wi = 0 , shifte in Schritt i nicht.
Ô Multiplexer-Schaltkreis mit k=log n Stufen und
O(n log n) Gattern.
CS - RA - SS01
Kap. 2.1
2.1/14
Barrel-Shifter für logischen Linksshift
Schritt i:
c
n
PSLL2i
wi
n
d
cn-1-2i
c0
cn-1
1
0
MUX
0
c2i
...
1
0
MUX
0
c2i-1
1
0
MUX
c0
...
1
0
MUX
wi
dn-1
d2i
d2i-1
d0
Falls wi = 0 , liefert PSLL2i die Eingabe c, sonst sll2i (c)
CS - RA - SS01
Kap. 2.1
2.1/15
Barrel-Shifter für logischen Linksshift
a
n
w0
PSLL20
n
w1
PSLL21
...
...
...
n
PSLL2n-1
wk-1
n
b
CS - RA - SS01
Kap. 2.1
2.1/16
Natürliche und ganze Zahlen
Sei a = (an −1 ,..., a0 )
z Natürliche Zahlen:
n −1
i
< an −1 ,..., a0 > = ∑ ai ⋅ 2
i =0
z Ganze Zahlen:
Darstellung im Zweierkomplement
n−2
[an −1 ,..., a0 ] = ∑ ai ⋅ 2 − 2
i
i=0
CS - RA - SS01
Kap. 2.1
n −1
⋅ an−1
2.1/17
Im Vergleich zu anderen Darstellungen
Darstellung
redundant /
irredundant
symmetrischer
Zahlenbereich
geeignet zum
Rechnen
Betrag und
Vorzeichen
redundant
ja
bedingt
EinerKomplement
redundant
ja
gut
Zweierkomplement
irredundant
nein
sehr gut
CS - RA - SS01
Kap. 2.1
2.1/18
Operationen
z
z
z
z
z
Addition (vgl. TI 2)
Subtraktion (vgl. TI 2)
Größenvergleich
Multiplikation (z.T. vgl. TI 2)
Division
z Zusätzlich zu beachten:
Bei allen Operationen muß eine Überlauferkennung
gewährleistet werden, um das overflow flag korrekt zu
setzen.
CS - RA - SS01
Kap. 2.1
2.1/19
Addition (Wiederholung)
z Carry-Ripple-Addierer:
Addition von n-Bit-Zahlen mit O(n) Gattern und
Tiefe O(n).
z Conditional-Sum-Addierer:
Addition von n-Bit-Zahlen mit O(nlog 3) Gattern
und Tiefe O(log n) (bzw. in modifizierter Version
mit O(n log n) Gattern).
z Carry-Lookahead-Addierer:
Addition von n-Bit-Zahlen mit O(n) Gattern und
Tiefe O(log n).
CS - RA - SS01
Kap. 2.1
2.1/20
Carry-Ripple-Addierer (Wdh.)
z Volladdierer zur Addition von „1-Bit-Zahlen“
Inputs
Outputs
A
B
CarryIn
CarryOut
Sum
Comments
0
0
0
0
0
0 + 0 + 0 = 00
0
0
1
0
1
0 + 0 + 1 = 01
0
1
0
0
1
0 + 1 + 0 = 01
0
1
1
1
0
0 + 1 + 1 = 10
1
0
0
0
1
1 + 0 + 0 = 01
1
0
1
1
0
1 + 0 + 1 = 10
1
1
0
1
0
1 + 1 + 0 = 10
1
1
1
1
1
1 + 1 + 1 = 11
EXOR-Gatter
( out=in 1⊕in2 )
OR-Gatter
(out=in1∨in2 )
cin
A
B
Sum
AND-Gatter
(out=in1∧in2 )
cout
z Carry-Ripple-Addierer als Kette von Volladdierern
CS - RA - SS01
Kap. 2.1
2.1/21
Conditional-Sum-Addierer (Wdh.)
A[3:0]
4
ALU
0
B[3:0]
4
A[7:4]
4
X[7:4]
4
B[7:4]
A[7:4]
4
4
C0
Y[7:4]
ALU
B[7:4]
4
0
0
1
2 to 1 MUX
4
1
1 Sel
C4
Result[3:0]
4
C4
Sel
2 to 1 MUX
ALU
berechnet auf den
höherwertigen Bitstellen
sowohl die Summe als
auch die Summe+1
CarryIn
Result[7:4]
4
C1
CarryOut
CS - RA - SS01
Kap. 2.1
2.1/22
Carry-Lookahead-Addierer (Wdh.)
z Addition wird zurückgeführt auf schnelle Berechnung der
Carry-Bits.
z Parallele Präfix-Berechnung, um schnelle Berechnung
von generate-/propagate-Signalen durchzuführen.
z Carry-Bits ergeben sich aus generate-/propagateSignalen.
CS - RA - SS01
Kap. 2.1
2.1/23
Addierer für natürliche Zahlen
z Es muß noch erkannt werden, ob ein Ausgangscarry /
Überlauf vorliegt!
z Situation 1:
Addierer liefert Ausgangscarry cn-1
→ klar
z Situation 2:
Addierer liefert cn-1 nicht, aber cn-2
→ cn −1 = (an −1bn −1 ) + (an−1 ⊕ bn−1 ) ⋅ cn − 2
z Situation 3:
Addierer liefert weder cn-1 nochcn-2
→ cn −1 = ( an −1bn−1 ) + (an −1 ⊕ bn −1 ) ⋅ sn −1
CS - RA - SS01
Kap. 2.1
2.1/24
Addierer für natürliche Zahlen:
Weiterrechnen bei Überläufen
z wrap-around Arithmetik: Überträge werden
weggelassen
z bei Audio-, Videoanwendungen: Ausgabe des
größten darstellbaren Wertes besser
---> Sättigungsarithmetik
auf sie kann bei vielen Prozessoren für die
digitale Signalverarbeitung umgeschaltet werden
CS - RA - SS01
Kap. 2.1
2.1/25
Wrap-around vs. Sättigungsarithmetik
Wrap-around
Arithmetik
SättigungsArithmetik
a
‘‘1000“
‘‘1000“
b
‘‘1000‘‘
‘‘1000‘‘
a+b
‘‘0000‘‘
‘‘1111‘‘
Bei Bereichsüberlauf wird der größte darstellbare Wert
zurückgeliefert.
CS - RA - SS01
Kap. 2.1
2.1/26
Wrap-around vs. Sättigungsarithmetik
Wrap-around
Arithmetik
SättigungsArithmetik
a
‘‘0001“
‘‘0001“
b
‘‘0011‘‘
‘‘0011‘‘
a-b
‘‘1110‘‘
‘‘0000‘‘
Bei Bereichsunterlauf wird der kleinste darstellbare Wert
zurückgeliefert.
CS - RA - SS01
Kap. 2.1
2.1/27
Addierer für ganze Zahlen im Zweierkomplement (1)
z Es kann ein Addierer für natürliche Zahlen verwendet
werden, abzuändern ist lediglich die Überlaufserkennung
(vgl. TI 2).
z Situation 1: Addierer liefert cn-1 und cn-2
→ overflow = cn −1 ⊕ cn −2
(vgl. TI 2, Vorlesung)
z Situation 2: Addierer liefert cn-1 und cn-2 nicht
→ overflow = ( an −1 ≡ bn−1 ) ⋅ ( sn −1 ⊕ an−1 )
(vgl. TI 2, Übung)
z Also gilt: Überlauf ist unabhängig vom Ausgangscarry
cn-1 !
CS - RA - SS01
Kap. 2.1
2.1/28
Addierer für ganze Zahlen im Zweierkomplement (2)
z Sättigungsarithmetik ähnlich wie bei natürlichen Zahlen.
z Fallunterscheidung bei Überlauf:
y Fall 1: a n −1 = bn −1 = 0
Liefere bei Überlauf 011..11 als Ergebnis (größte darstellbare
Zahl).
y Fall 2: an −1 = bn −1 = 1
Liefere bei Überlauf 100..00 als Ergebnis (kleinste darstellbare
Zahl).
CS - RA - SS01
Kap. 2.1
2.1/29
Subtrahierer
z Ganze Zahlen im Zweierkomplement:
Verwende Zweierkomplementaddierer wegen
y a − b = a + ( −b)
y − [bn −1 ,..., b0 ] = [bn−1 ,..., b0 ] + 1
z Natürliche Zahlen mit n Bit:
y Verwende (n+1)-Bit-Subtrahierer für ganze Zahlen (ergänze vor
der Subtraktion jeweils 0 als Vorzeichenbit)
y Überlauf, wenn sn = 1 (wenn Ergebnis negativ).
y Genauere Betrachtung zeigt:
n-Bit-Subtrahierer für ganze Zahlen genügt!
Grund: sn läßt sich rekonstruieren aus an-1, bn-1 und sn-1
(siehe Übung)
CS - RA - SS01
Kap. 2.1
2.1/30
Größenvergleich für ganze Zahlen
z Bei vielen Rechnern führen arithmetische Operationen
zu Setzen bzw. Rücksetzen von Statusbits in einem
Statusregister (Condition Code Register).
z Hier: Vergleiche zwei Zweierkomplementzahlen a und b
durch
y Subtraktion a-b
y Verwendung von overflow flag, zero flag und sign flag, um
Vergleichergebnis zu bestimmen
y Insbesondere soll Vergleichsergebnis auch beim Auftreten eines
Overflows berechenbar sein!
y ov:= overflow flag
y sf := sign flag, sf = 1 gdw. sn-1=1
y zf := zero flag, zf = 1 gdw. si = 0 für i=0,...,n-1
CS - RA - SS01
Kap. 2.1
2.1/31
Größenvergleich für ganze Zahlen
ov = ( an−1 ≡ bn−1 ) ⋅ ( sn −1 ⊕ an −1 ) = ( an −1 ⊕ bn −1 ) ⋅ ( sf ⊕ an −1 )
⇒
sf = 1 ⇔ ov = an −1bn −1
sf = 0 ⇔ ov = an −1 bn −1
ov sf
0 0
0 1
1 0
1 1
Kommentar
kein Überlauf, s = a-b ≥ 0
Kein Überlauf, s = a-b neg.
an −1 = 1, bn −1 = 0 , a neg., b ≥ 0
an −1 = 0, bn−1 = 1 , a ≥ 0, b neg.
Ergebnis
a≥b
a<b
a<b
a>b
a < b ⇔ ov ⊕ sf
a ≤ b ⇔ (a < b) ∨ (a = b) ⇔ (ov ⊕ sf ) ∨ zf
a > b ⇔ (a ≤ b) ⇔ (ov ⊕ sf ) ∨ zf ⇔ (ov ≡ sf ) ⋅ zf
a ≥ b ⇔ a < b ⇔ ov ≡ sf
CS - RA - SS01
Kap. 2.1
2.1/32
Größenvergleich
z Die erwähnten Beziehungen werden vielfach genutzt,
um anhand der Werte im Condition-Code-Register
Verzweigungsbedingungen abzutesten, die vom
Größenvergleich zweier ganzer Zahlen abhängen.
(Hierbei ist zu beachten, daß Größenvergleiche wegen
der möglichen Überläufe nicht einfach durch Subtraktion
und Vorzeichentest des Ergebnisses erfolgen dürfen.)
z Größenvergleich natürlicher Zahlen: Analog.
CS - RA - SS01
Kap. 2.1
2.1/33
Multiplikation natürlicher und ganzer
Zahlen
z ... liefert Produkt natürlicher bzw. ganzer Zahlen, soweit
dies aufgrund der üblichen festen Datenwortlänge
möglich ist
n
{
0
,...,
2
− 1}
z Natürliche Zahlen mit n Bit liegen im Bereich
2n
n+1
⇒ Produkt liegt im Bereich {0,...,2 − 2 + 1}
⇒ Produkt darstellbar mit 2n Bit
z Ganze Zweierkomplementzahlen mit n Bit liegen im
n −1
n−1
Bereich {−2 ,...,2 − 1}
2 n −2
+ 2 n−1 ,...,2 2n −2 − 2 n + 1}
⇒ Produkt liegt im Bereich {−2
⇒ Produkt darstellbar mit 2n-1 Bit
CS - RA - SS01
Kap. 2.1
2.1/34
Multiplikation natürlicher und ganzer
Zahlen
z Lösung auf Maschinenspracheebene:
y Produkt wird meist durch einen Bitvektor dargestellt, der
doppelte Länge wie Argumente hat
y Auf niederwertige und höherwertige Hälfte des Produkts kann
getrennt zugegriffen werden (Kopieren, Abspeichern etc.)
y Grund für Darstellung des vollen Ergebnisses:
Bei softwaremäßigem Multiplizieren sehr großer Zahlen (> n Bit)
ist es von Vorteil, das volle Ergebnis der Multiplikation von n-BitZahlen zur Verfügung zu haben.
z Höhere Programmiersprachen:
y Vergrößerter Zahlenbereich steht meist nicht zur Verfügung
y Overflow-Behandlung nötig!
CS - RA - SS01
Kap. 2.1
2.1/35
Multiplikation natürlicher und ganzer
Zahlen
z Multiplikation ganzer Zahlen wird meist zurückgeführt
auf die Multiplikation natürlicher Zahlen.
y
y
y
y
Berechnung der Beträge
Multiplikation
Berechnung des Vorzeichens des Produkts (an−1 ⊕ bn −1 )
Bei negativem Ergebnis: Berechnung des Inversen im
Zweierkomplement
z Ausnahme: Verfahren von Booth
CS - RA - SS01
Kap. 2.1
2.1/36
Zur Erinnerung:
Multiplikation natürlicher Zahlen
z „Parallele“ (kombinatorische) Multiplizierer (TI 2):
(∑
n −1
) (∑
a2 ⋅
i=0 i
i
)
n−1
j
b
2
=
j =0 j
(
)
=< a > ⋅ ∑ j =0 b j 2 j = ∑ j =0 < a > b j 2 j
n −1
n −1
= ∑ j =0 < an−1b j ,..., a0b j > 2 = ∑ j =0 Pj
144424443
Pj
n −1
j
n −1
y Berechne Partialprodukte Pj parallel durch n2 AND-Gatter.
y „Lineares“ Aufsummieren: O(n2) Gatter, Tiefe O(n logn)
y „Baumartiges“ Ausummieren: O(n2) Gatter, Tiefe O(log2n)
y „Wallace-Tree“: O(n2) Gatter, Tiefe O(log n)
CS - RA - SS01
Kap. 2.1
2.1/37
Multiplikation natürlicher Zahlen
z „Sequentielle Multiplizierer“:
y Faktoren und Zwischenergebnisse sind in Registern
abgespeichert
y Nutze 1 vorhandenen Addierer zum Aufsummieren
CS - RA - SS01
Kap. 2.1
2.1/38
Booth-Verfahren als Verbesserung der
Multiplikation nach der Schulmethode
Sequentielle Multiplikation
nach der Schulmethode
x
y
0
0
0
1
1
0
1
1
x⋅y0
0
0
1
1
shift
x⋅y1
add
0
0
0
0
0
0
0
0
0
1
0
1
1
shift
x⋅y2
add
0
0
0
0
0
0
0
1
1
0
1
1
1
1
1
1
shift
x⋅y3
add
0
0
0
0
0
0
0
0
0
1
0
1
1
1
1
1
1
1
CS - RA - SS01
z Insgesamt werden n
Additionen in n Takten
ausgeführt, insbesondere
Additionen mit Null sind
überflüssig.
1
Kap. 2.1
2.1/39
Verfahren von Booth
A. Booth. A Signed Binary Multiplication Scheme. Q.J.Mech.Appl.Math.
4:236:240 (1951)
Beobachtung
z Enthält der Multiplikator y einen Nullblock der Länge k, so kann die
Multiplikation durch ein Shift der Zwischensumme um k Stellen
beschleunigt werden.
z Enthält der Multiplikator y einen Einsblock von Stelle u bis Stelle v,
z.B.:
0.....01........10............0
v
u
so können die zum Einsblock gehörigen (v-u+1)
Additionen der Multiplikation nach Schulmethode wegen
<0...01...10...0>=2v+1-2u durch eine Addition an der Stelle v+1
und eine Substraktion an der Stelle u ersetzt werden
CS - RA - SS01
Kap. 2.1
2.1/40
Verfahren von Booth
z Arithmetische Operationen sind nur bei 0→1 und 1→0 Wechsel im
Multiplikator erforderlich.
z Um diese Wechsel zu erkennen, muß man in Schritt i noch das Bit
yi-1 des Multiplikators zusätzlich betrachten.
z
Man erhält die Rechenvorschrift
yi yi-1 Operation
0
0
1
1
0
1
0
1
shift
add; shift
sub; shift
shift
mit y-1=0
CS - RA - SS01
Kap. 2.1
2.1/41
Verfahren von Booth: Beispiel
x
y3
y2
y1
y0
0010
0
1
1
0
↑
Operation
Zwischenergebnis
0000
shift
0000 0
↑
sub (add 1110)
1110 0
↑
shift
1111 00
↑
shift
add 0010
1111 100
0001 100
↑
shift
0000 1100
↑
Daß das Verfahren von Booth auch für Zweierkomplementzahlen das
richtige Ergebnis liefert, ist nicht unmittelbar einsichtig ...
CS - RA - SS01
Kap. 2.1
2.1/42
Korrektheit des Verfahrens von Booth
Satz
Das Verfahren von Booth multipliziert sowohl positive als auch negative
Zahlen im Zweierkomplement.
Beweis
Wir betrachten im Verfahren von Booth an jeder Stelle die Differenz
(yi-1-yi) und berechnen das Multiplikationsergebnisses durch die Summe
S = (y-1-y0)⋅20⋅ <x> +
(y0 -y1)⋅21⋅ <x> +
...
(yn-3 -yn-2)⋅2n-2 ⋅ <x> +
(yn-2 -yn-1)⋅2n-1 ⋅<x>
= <x>⋅(-yn-1⋅2n-1 + yn-2 ⋅2n-2 +...+ y1⋅21 + y0⋅20)
= <x> ⋅ <y>
CS - RA - SS01
Kap. 2.1
yi
yi-1
Operation
0
0
1
1
0
1
0
1
shift
add; shift
sub; shift
shift
mit y-1=0
2.1/43
Hardwarerealisierung der Methode von
Booth
z Multiplikation wird unter der Verwendung der Additionshardware
implementiert:
Multiplicand
32 bits
Multiplier Shift
right
32-bit ALU
32 bits
32 bits
Product
Shift right
Control
write
64 bits
32 bits
CS - RA - SS01
Vor der j-ten Iteration nur die Belegung
der j signifikantesten Bitstellen von Bedeutung
Kap. 2.1
2.1/44
Billigere Realisierung
Multiplicand
32 bits
32-bit ALU
32 bits
Product
Shift right
write
Control
64 bits
32 bits
CS - RA - SS01
Speichere den Multiplikator
in die hinteren 32 Bitstellen
Kap. 2.1
2.1/45
Verfahren von Booth
z Was haben wir bisher durch das Verfahren von Booth
gewonnen?
y Einsparung von Additionen bzw. Subtraktionen durch
Berücksichtigung von 0-Blöcken bzw. 1-Blöcken
y Aber: Weiterhin n Takte (n Shifts) nötig!
z Verbesserung:
y Zusammenfassen von k 1-Bit-Shifts in k Takten zu k-Bit-Shifts in
einem Takt
Ô Barrelshifter
Ô Dazu muß am Ende des (geshifteten) Multiplikators die Länge
des aktuellen 0- bzw. 1-Blocks bestimmt werden.
Ô Benutze dazu Prioritätsencoder
CS - RA - SS01
Kap. 2.1
2.1/46
Prioritätsencoder
xn-1
n = 2k
....
x0
xn-1
....
x0
PE_FIRST_0
PE_FIRST_1
...
...
z
yk-1
y0
z
yk-1
y0
z = 1, < y >= i , falls ∃i : xi = 0
z = 1, < y >= i , falls ∃i : xi = 1
und ∀j < i : x j = 1
z = 0, y bel., falls xi = 1 ∀i
und ∀j < i : x j = 0
z = 0, y bel., falls xi = 0 ∀i
Prioritätsencoder lassen sich mit O(n) Gattern in Tiefe O(log n)
realisieren.
CS - RA - SS01
Kap. 2.1
2.1/47