Der Brent-Kung-Addierer wurde 1982 von Hsiang Te Kung und Richard Peirce Brent vorgeschlagen. Es handelt sich um einen parallelen Präfix-Addierer oder Baum-Addierer, der aufgrund seiner Flexibilität häufig im digitalen Design verwendet wird. Parallele Präfixaddierer können basierend auf der Anzahl der Logikebenen auf verschiedene Arten erstellt werden. Logikgatter beteiligt, der Fan-Out von jedem Gate und die Verkabelung zwischen den Ebenen. Es stehen verschiedene Arten von Baumaddierern zur Verfügung. Die grundlegenden Baumaddierer sind Sklanskym KoggeStone und Brent-Kung. Im Vergleich zum KSA (Kogge-Stone-Addierer) bietet dieser Addierer eine hohe Regelmäßigkeit in der Struktur des Addierers und weist eine geringere Verdrahtungsblockierung auf was zu einer besseren Leistung und weniger benötigter Chipfläche führt. Dieser Artikel enthält kurze Informationen zu a Brent Kung Adder .
Was ist Brent Kung Adder?
Ein Addierer, der ein Minimum an Schaltkreisen verwendet, um das Ergebnis zu erhalten, ist als Brent-Kung-Addierer bekannt und wird auch als Addierer mit geringem Stromverbrauch oder Paralleladdierer bezeichnet. Dieser Addierer soll die Größe des Chips einsparen, sodass die Herstellung dieser Addierer einfacher wird. Die Symmetrie und die übliche Konstruktionsstruktur dieses Addierers senken die Produktionskosten erheblich und ermöglichen den Einsatz in Pipeline-Topologien. Die Verwendung komplementärer Transistorlogik trägt zur Verbesserung der Designleistung bei Multiplexer Ansatz in verschiedenen Zelldesigns.
Brent Kung Adder Circuit
Das Diagramm des parallelen Präfixaddierers von Brent-Kung ist unten dargestellt und umfasst Stufe 1 (Vorverarbeitungsstufe), Stufen 2 bis 7 sind Übertragserzeugungsstufen und Stufe 8 ist Nachverarbeitung. Es handelt sich um eine fortschrittliche Architektur, die sehr einfach zu konstruieren ist und weniger Kabelstau verursacht. Aufgrund der geringeren Verkabelung verringert sich der Platzbedarf für die Ausführung der Architektur. Darüber hinaus wird die Verlegung viel einfacher, da sich weniger Drähte kreuzen (oder überlappen). Aufgrund der erhöhten Anzahl von Stufen erhöht sich jedoch die Strafe bei der Verzögerung. Der Fan-Out für diesen Addierer wird erhöht, und dann wird die Verzögerung erhöht.
Wie funktioniert Brent Kung Adder?
Brent Kung Adder berechnet die Präfixe für zwei Bitgruppen, die beim Finden der 4-Bit-Gruppenpräfixe hilfreich sind. Diese Präfixe werden zur Berechnung der Präfixe der 8-Bit-Gruppe usw. verwendet. Anschließend werden diese Präfixe zur Berechnung des Übertrags der spezifischen Bitstufe verwendet. Diese Überträge werden mit der Group Propagate der nächsten Stufe verwendet, um das Summenbit dieser Stufe zu berechnen. Brent Kung Tree verwendet 2log2N – 1 Stufe.
32-Bit-Brent-Kung-Addierer
Das 32-Bit-Brent-Kung-Addierer-Layout ist unten dargestellt. Zu Beginn dieses Layouts werden grundlegende Logikgatter wie NAND, Inverter, XOR, NOR usw. entworfen. Anschließend werden die erforderlichen Zellen wie schwarze Zellen, graue Zellen, Puffer und PG-Logik mit den Logikgattern entworfen.
Im folgenden 32-Bit-Brent-Kung-Addierer werden die invertierenden Gatter wie AOI und OAI alternativ hauptsächlich für graue und schwarze Zellen verwendet. Die schwarzen und grauen Zellen werden also durch graue und schwarze Blöcke dargestellt, während die Puffer durch Kreise dargestellt werden.
Die Eingänge wie A und B werden der PG-Logik zugeführt, die im Blockdiagramm dargestellt ist. Für einen 32-Bit-Addierer sind 32 PG-Logikblöcke erforderlich und die Signale „Propagate“ (P) und „Generate“ (G) sind die Ausgänge dieses Blocks. Diese Signale werden der Baumstruktur des Brent-Kung-Addierers zugeführt. Die Struktur dieses Addierers umfasst graue und schwarze Zellen.
Eine graue Zelle enthält drei Eingaben und eine Ausgabe. Die Ausbreitungs- und Generierungssignale der aktuellen Stufe sowie die Generierungssignale der vorherigen Stufe sind Eingänge, während die Gruppe „Generierungssignale“ der O/P ist. In jeder Baumstruktur endet jede Stufe mit einer grauen Zelle und das O/P dieser Zelle ist das Gruppengenerierungssignal. Dieses Signal wird einfach als Übertrag dieser Stufe betrachtet. Die schwarze Zelle umfasst vier Eingänge und zwei Ausgänge. Die Eingänge für diese Zelle sind die P- und G-Signale der aktuellen Stufe sowie die P- und G-Signale der vorherigen Stufe.
Eine PG-Logik umfasst UND- und XOR-Gatter, wobei das UND-Logikgatter zum Erzeugen des G-Signals verwendet wird und das XOR-Logikgatter das P-Signal bereitstellt. Um unnötige Wechselrichter zu vermeiden, werden zwei Arten von grauen und schwarzen Zellen verwendet. Die in einer Reihe für die graue Zelle verwendeten invertierenden Gatter sind AOI oder UND-ODER-Inverter und die invertierenden Gatter für die schwarze Zelle in der nächsten Reihe verwenden OAI oder ODER-UND-Inverter. Die AOI-Zelle verwendet die normalen Eingänge, um invertierte Ausgänge bereitzustellen, während die OAI invertierte Eingänge verwendet, um normale Ausgänge bereitzustellen.
Brent-Kung-Addierer-Operation
Der Brent-Kung-Addierer ist ein paralleler Präfixaddierer, der für den Betrieb einer Hochleistungsaddition verwendet wird. Dieser Addierer sieht aus wie eine Baumstruktur, die die arithmetische Operation ausführt. Dieser Addierer umfasst schwarze und graue Zellen. Jede schwarze Zelle hat zwei UND-Gatter und ein einzelnes ODER-Gatter und jede graue Zelle hat nur ein einziges UND-Gatter.
Der Brent-Kung-Addierer umfasst zwei Stufen; die Vorverarbeitungsphase und die Generierungsphase. In der ersten Phase erfolgt die Generierung und Weitergabe von jedem Eingabepaar. Hier bietet „Propagate“ eine „XOR“-Operation für Eingabebits, während „Generate“ eine „AND“-Operation für Eingabebits bereitstellt. Die Ausbreitungs- und Generierungsfunktionen wie „Pi“ und „Gi“ sind unten angegeben.
Pi = Ai XOR Bi und Gi = Ai AND Bi.
In der zweiten Stufe wird der Übertrag für jedes Bit erzeugt, was als Übertragsgenerierung „Cg“ bekannt ist, und der Übertrag wird für jedes Bit weitergegeben, was als Übertragsgenerierung „Cp“ bekannt ist. Für die weitere Operation werden „Carry Propagate“ und „Carry Generate“ generiert. Die letzte verfügbare Zelle innerhalb der Bit-Operation liefert den Übertrag. Der letzte Bitübertrag hilft also dabei, das nächste Bit gleichzeitig bis zum letzten Bit zu summieren. Die Übertragsgenerierung und -verbreitung werden wie folgt angegeben:
Cp = P1 UND P0 und Cg=G1 ODER (P1 UND G0)
Es wird hauptsächlich für die Additionsoperation von zwei und zweiunddreißig Bits verwendet. Jedes Bit durchläuft die Vorverarbeitungs- und Generierungsphase und liefert dann die Endsumme.
Die primären Eingabebits gehen unter die Vorverarbeitungsstufe und erzeugen eine Ausbreitung und Generierung. Diese breiten sich also aus und erzeugen eine Generierungsphase, erzeugen einen Übertrag, erzeugen einen Übertrag und verbreiten sich weiter und liefern die Endsumme. Der Schritt-für-Schritt-Prozess des Brent-Kung-Addierers ist unten dargestellt.
Die Brent-Kung-Addiereranordnung sieht aus wie eine Baumstruktur und ist der Hochgeschwindigkeitsaddierer, der auf die Logik auf Gatterebene abzielt. Dieser Addierer kann mit einer Verringerung der Anzahl der Logikgatter entworfen werden. Dadurch werden die Verzögerung und der Speicherbedarf innerhalb dieser Architektur reduziert.
Brent Kung Adder Verilog-Code
Der Verilog-Code des Brent-Kung-Addierers ist unten dargestellt.
`define INPUTSIZE 64 //setze die Eingabegröße n
`define GROUPSIZE 8 //setze die Gruppengröße = 1, 2, 4 oder 8
Modul Brent_Kung_Adder(A, B, S);
input [`INPUTSIZE – 1:0] A;
input [`INPUTSIZE – 1:0] B;
Ausgabe [`INPUTSIZE:0] S;
Wire [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
wire [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
wire [`INPUTSIZE / `GROUPSIZE:0] cin;
Wire [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
weise cin[0] = 1’b0 zu;
generieren
wo drin;
for (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) begin: parallel_FA_CLA_prefix
group_q_generation #(.Groupsize(`GROUPSIZE))
F(
.a(A[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.b(B[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.cin(cin[i]),
.s(S[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.qg(q[i * 2 + 1:i * 2])
);
Ende
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0])
);
parallel_prefix_tree_second_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t2(
.q(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r[`INPUTSIZE / `GROUPSIZE * 2 – 1:0])
);
for (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) begin: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1’b0),
.cin(cin[i + 1])
);
Ende
zuweisen S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
endgenerieren
Endmodul
// Erste Hälfte des parallelen Präfixbaums
module parallel_prefix_tree_first_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
input [Treesize * 2 – 1:0] q;
Ausgabe [Baumgröße * 2 – 1:0] r;
generieren
wo drin;
if (Treesize == 2) begin: trivial_case
zuweisen r[1:0] = q[1:0];
prefix_logic f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
end else begin: recursive_case
Wire [Treesize * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_lsbh(
.q(q[Baumgröße – 1:0]),
.r(r_temp[Baumgröße – 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_msbh(
.q(q[Baumgröße * 2 – 1:Baumgröße]),
.r(r_temp[Treesize * 2 – 1:Treesize])
);
for (i = 0; i < Treesize * 2; i = i + 2) begin: parallel_stitch_up
if (i != Treesize * 2 – 2) begin: parallel_stitch_up_pass
weisen Sie r[i + 1:i] = r_temp[i + 1:i] zu;
end else begin: parallel_stitch_up_produce
prefix_logic f(
.ql(r_temp[Treesize – 1:Treesize – 2]),
.qh(r_temp[Treesize * 2 – 1:Treesize * 2 – 2]),
.r(r[Baumgröße * 2 – 1:Baumgröße * 2 – 2])
);
Ende
Ende
Ende
endgenerieren
Endmodul
// Zweite Hälfte des parallelen Präfixbaums
module parallel_prefix_tree_second_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
input [Treesize * 2 – 1:0] q;
Ausgabe [Baumgröße * 2 – 1:0] r;
Wire [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
zuweisen r_temp[Treesize * 2 – 1:0] = q[Treesize * 2 – 1:0];
generieren
genvar i, j;
for (i = 0; i < $clog2(Treesize) – 2; i = i + 1) begin: second_half_level
weisen Sie r_temp[Treesize * 2 * (i + 1) + ((Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i)) * 2 – 1:Treesize * 2 zu * (i + 1)] = r_temp[Treesize * 2 * i + ((Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i)) * 2 – 1: Baumgröße * 2 * i];
for (j = (Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i); j < Treesize; j = j + 2 ** ($clog2(Treesize / 2 ) – i)) begin: second_half_level_logic
prefix_logic f(
.ql(r_temp[Treesize * 2 * i + (j – 2 ** ($clog2(Treesize / 4) – i)) * 2 + 1:Treesize * 2 * i + (j – 2 ** ($clog2( Baumgröße / 4) – i)) * 2]),
.qh(r_temp[Treesize * 2 * i + j * 2 + 1:Treesize * 2 * i + j * 2]),
.r(r_temp[Treesize * 2 * (i + 1) + j * 2 + 1:Treesize * 2 * (i + 1) + j * 2])
);
if (j != Treesize – 1 – 2 ** ($clog2(Treesize / 4) – i)) begin: second_half_level_direct_connect
weisen Sie r_temp[Treesize * 2 * (i + 1) + (j + 2 ** ($clog2(Treesize / 2) – i)) * 2 – 1:Treesize * 2 * (i + 1) + j * 2 + zu 2] = r_temp[Treesize * 2 * i + (j + 2 ** ($clog2(Treesize / 2) – i)) * 2 – 1:Treesize * 2 * i + j * 2 + 2];
Ende
Ende
weisen Sie r_temp[Treesize * 2 * (i + 2) – 1:Treesize * 2 * (i + 2) – (2 ** ($clog2(Treesize / 4) – i)) * 2] = r_temp[Treesize * 2 zu * (i + 1) – 1:Treesize * 2 * (i + 1) – (2 ** ($clog2(Treesize / 4) – i)) * 2];
Ende
zuweisen r[1:0] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + 1:Treesize * 2 * ($clog2(Treesize) – 2)];
for (i = 1; i < Treesize; i = i + 2) begin: final_r_odd
weisen Sie r[i * 2 + 1:i * 2] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + zu ich * 2];
Ende
for (i = 2; i < Treesize; i = i + 2) begin: final_r_even
prefix_logic f(
.ql(r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 – 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 – 2]),
.qh(r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
Ende
endgenerieren
Endmodul
module group_q_generation #(parameter Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
input [Gruppengröße – 1:0] a;
input [Gruppengröße – 1:0] b;
Eingabe cin;
Ausgabe [Gruppengröße – 1:0] s;
Ausgabe [1:0] qg;
Draht [2 * Gruppengröße – 1:0] q;
Draht [Gruppengröße – 1:0] c;
weise c[0] = cin zu;
generieren
wo drin;
for (i = 0; i < Groupsize; i = i + 1) begin: parallel_FA_CLA_prefix
FA_CLA_prefix f(
.a(a[i]),
.b(b[i]),
.cin(c[i]),
.s(s[i]),
.q(q[i * 2 + 1:i * 2])
);
if (i != Groupsize – 1) begin: special_case
Weisen Sie c[i + 1] = q[i * 2 + 1] | zu (q[i * 2] & c[i]);
Ende
Ende
//Gruppen-Q-Generierung basierend auf der Gruppengröße
if (Groupsize == 1) begin: case_gs1
weisen Sie qg[1] = q[1] zu;
weise qg[0] = q[0] zu;
end else if (Groupsize == 2) begin: case_gs2
weise qg[1] = q[3] | zu (q[1] & q[2]);
weisen Sie qg[0] = q[2] & q[0] zu;
end else if (Groupsize == 4) begin: case_gs4
weise qg[1] = q[7] | zu (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
weisen Sie qg[0] = q[6] & q[4] & q[2] & q[0] zu;
end else if (Groupsize == 8) begin: case_gs8
weise qg[1] = q[15] | zu (q[13] & q[14]) | (q[11] & q[14] & q[12]) | (q[9] & q[14] & q[12] & q[10]) | (q[7] & q[14] & q[12] & q[10] & q[8]) | (q[5] & q[14] & q[12] & q[10] & q[8] & q[6]) | (q[3] & q[14] & q[12] & q[10] & q[8] & q[6] & q[4]) | (q[1] & q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2]);
weisen Sie qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0] zu;
Ende
endgenerieren
Endmodul
// Cin-Generierungslogik
Modul cin_generation_logic(r, c0, cin);
Eingabe [1:0] r;
Eingang c0;
Ausgang cin;
cin = (r[0] & c0) | zuordnen r[1];
Endmodul
// Grundlegende Logik für Präfixoperationen
Modul prefix_logic(ql, qh, r);
Eingabe [1:0] ql;
Eingabe [1:0] qh;
Ausgabe [1:0] r;
zuweisen r[0] = qh[0] & ql[0];
weise r[1] = (qh[0] & ql[1]) | zu qh[1];
Endmodul
// Volladdiererzelle mit Carry-Look-Ahead
Modul FA_CLA_prefix(a, b, cin, s, q);
Eingabe a;
Eingabe b;
Eingabe cin;
Ausgabe s;
Ausgabe [1:0] q;
weisen Sie q[0] = a ^ b zu;
zuweisen s = q[0] ^ cin;
weise q[1] = a & b zu;
Endmodul
Vorteile
Zu den Vorteilen von Brent Kung Adder gehören die folgenden.
- Dies ist ein Addierer mit geringem Stromverbrauch, da er eine minimale Schaltung verwendet, um das Ergebnis zu erhalten.
- Es ist ein sehr beliebter und weit verbreiteter Addierer.
- Diese Art von Addierer kann im Vergleich zu einem Kogge-Stone-Addierer mit weniger Modulen implementiert werden.
- Das Entwerfen von Brent-Kung-Addierern ist sehr einfach.
- Dieser Addierer hat weniger Verbindungen zu anderen Modulen.
- Diese Addierer wurden hauptsächlich vorgeschlagen, um die Nachteile der Kogge-Stone-Addierer zu beheben.
Nachteile
Der Nachteile von Brent Kung Adde r umfassen Folgendes.
- Diese Addierer haben eine größere Verzögerung und benötigen 2 log2 n − 2 Logikpegel zur Berechnung aller Übertragsbits.
- Der Hauptnachteil dieses Addierers ist der Fanout, der dazu führen kann, dass sich der Strom im gesamten Addierer aufteilt und schwächer wird.
Brent Kung Adder-Anwendungen
Zu den Anwendungen von Brent Kung Adder gehören die folgenden.
- Ein Brent-Kung-Addierer wird im Pipeline-Verfahren verwendet, um den Stromverbrauch durch Verringerung der kombinatorischen Logiktiefe und der Störimpulsstabilisierung zu senken.
- Der Brent-Kung-Addierer bietet eine hervorragende Anzahl von Stufen von I/P bis zu allen O/PS, jedoch mit asymmetrischer Belastung der Zwischenstufen.
- Dieser Addierer kann sowohl im Multiplikator als auch in anderen Datenpfadelementen verwendet werden.
Das ist also so eine Übersicht über Brent-Kung-Addierer , seine Funktionsweise, Vorteile, Nachteile und seine Anwendungen. Dies ist ein sehr effizienter Addierer und seine Struktur ähnelt einer Baumstruktur, die hauptsächlich für Hochleistungsarithmetikoperationen verwendet wird. Dieser Addierertyp ist sehr schnell und konzentriert sich hauptsächlich auf die Logik auf Gatterebene. Dieser Addierer ist so konzipiert, dass er weniger Logikgatter verwendet. Dadurch werden der in dieser Architektur verwendete Speicher und die Verzögerung reduziert. Hier ist eine Frage an Sie, Brent Kung Adder, auch bekannt als?
