Ο αθροιστής Brent–Kung προτάθηκε το 1982 από τους Hsiang Te Kung & Richard Peirce Brent. Είναι ένας αθροιστής παράλληλου προθέματος ή αθροιστής δέντρων που χρησιμοποιείται ευρέως στον ψηφιακό σχεδιασμό λόγω της ευελιξίας του. Οι παράλληλοι αθροιστές προθέματος μπορούν να κατασκευαστούν με διάφορους τρόπους με βάση τον αριθμό των λογικών επιπέδων, λογικές πύλες εμπλέκονται, ο ανεμιστήρας από κάθε πύλη & η καλωδίωση μεταξύ των επιπέδων. Υπάρχουν διάφοροι τύποι αθροιστών δέντρων, οι βασικοί αθροιστές δέντρων είναι οι Sklanskym KoggeStone & Brent-Kung, Σε σύγκριση με το KSA (Kogge–Stone adder), αυτός ο αθροιστής παρέχει υψηλή κανονικότητα στη δομή του αθροιστή και έχει λιγότερο μπλοκάρισμα καλωδίωσης που οδηγεί σε καλύτερη απόδοση & λιγότερο απαιτούμενη περιοχή τσιπ. Αυτό το άρθρο παρέχει σύντομες πληροφορίες για α Μπρεντ Κουνγκ Άντερ .
Τι είναι το Brent Kung Adder;
Ένας αθροιστής που χρησιμοποιεί ελάχιστο κύκλωμα για να πάρει το αποτέλεσμα είναι γνωστός ως αθροιστής Brent Kung και είναι επίσης γνωστός ως αθροιστής χαμηλής ισχύος ή παράλληλος αθροιστής. Αυτός ο αθροιστής προορίζεται να εξοικονομήσει το μέγεθος του τσιπ, έτσι ώστε η κατασκευή αυτών των αθροιστών να γίνει ευκολότερη. Η συμμετρία και η συνήθης δομή κατασκευής αυτού του αθροιστή θα μειώσει σημαντικά το κόστος παραγωγής και επιτρέπεται να χρησιμοποιηθούν σε τοπολογίες με σωλήνωση. Η χρήση της λογικής συμπληρωματικού τρανζίστορ διέλευσης βοηθά στη βελτίωση της απόδοσης σχεδιασμού με το πολυπλέκτης προσέγγιση σε διάφορα σχέδια κυψελών.
Σιρκουί Brent Kung Adder
Το διάγραμμα αθροιστή παράλληλου προθέματος brent-kung φαίνεται παρακάτω, το οποίο περιλαμβάνει το στάδιο 1 (στάδιο προεπεξεργασίας), τα στάδια 2 έως 7 είναι στάδια παραγωγής μεταφοράς και το στάδιο 8 είναι η μετα-επεξεργασία. Είναι μια προηγμένη αρχιτεκτονική και είναι πολύ απλή στην κατασκευή και παρέχει λιγότερη συμφόρηση καλωδίωσης. Έτσι, η λιγότερη καλωδίωση θα μειώσει την ποσότητα του απαιτούμενου χώρου για την εκτέλεση της αρχιτεκτονικής. Επιπλέον, η δρομολόγηση γίνεται πολύ πιο εύκολη λόγω διασταύρωσης (ή) επικάλυψης λιγότερων καλωδίων. Ωστόσο, η ποινή θα αυξηθεί σε καθυστέρηση, λόγω του αυξημένου αριθμού σταδίων, Το fan out για αυτόν τον αθροιστή αυξάνεται και, στη συνέχεια, η καθυστέρηση θα αυξηθεί.
Πώς λειτουργεί το Brent Kung Adder;
Το Brent Kung Adder λειτουργεί υπολογίζοντας τα προθέματα για δύο ομάδες bit που είναι χρήσιμα για την εύρεση των προθεμάτων ομάδων 4 bit. Αυτά τα προθέματα χρησιμοποιούνται για τον υπολογισμό των προθεμάτων της ομάδας 8-bit, κ.λπ. Στη συνέχεια, αυτά τα προθέματα θα χρησιμοποιηθούν για τον υπολογισμό της εκτέλεσης του συγκεκριμένου σταδίου bit. Αυτές οι μεταφορές χρησιμοποιούνται με το Group Propagate του επόμενου σταδίου για τον υπολογισμό του Sum bit αυτού του σταδίου. Το Brent Kung Tree χρησιμοποιεί 2log2N – 1 στάδιο.
32-bit Brent Kung Adder
Η διάταξη αθροιστή Brent Kung 32 bit φαίνεται παρακάτω. Στην αρχή αυτής της διάταξης, οι βασικές λογικές πύλες σχεδιάζονται όπως NAND, μετατροπέας, XOR, NOR, κ.λπ. Μετά από αυτό, τα απαραίτητα κελιά όπως μαύρα κελιά, γκρι κελιά, buffers και λογική PG σχεδιάζονται με τις λογικές πύλες.
Στον κάτω 32-bit αθροιστή Brent Kung, οι αναστροφικές πύλες όπως AOI & OAI χρησιμοποιούνται εναλλακτικά για κυρίως γκρι και μαύρα κελιά. Έτσι, τα μαύρα και γκρι κελιά αντιπροσωπεύονται με γκρι & μαύρο μπλοκ ενώ τα buffer αντιπροσωπεύονται με κύκλους.
Οι είσοδοι όπως το A & B παρέχονται στη λογική PG που φαίνεται στο μπλοκ διάγραμμα. Για έναν αθροιστή 32 bit, είναι απαραίτητα 32 λογικά μπλοκ PG και τα σήματα διάδοσης (P) και δημιουργίας (G) είναι οι έξοδοι αυτού του μπλοκ. Αυτά τα σήματα παρέχονται στη δομή δέντρου αθροιστή Brent Kung. Η δομή αυτού του αθροιστή περιλαμβάνει γκρι κελιά & μαύρα κελιά.
Ένα γκρι κελί περιλαμβάνει τρεις εισόδους και μία έξοδο. Η διάδοση και η παραγωγή σημάτων από το παρόν στάδιο και η παραγωγή σημάτων από το προηγούμενο στάδιο είναι είσοδοι ενώ η ομάδα που παράγει σήματα είναι το o/p. Σε οποιαδήποτε δομή δέντρου, κάθε στάδιο θα τελειώνει με ένα γκρι κελί και το o/p αυτού του κελιού είναι το σήμα που δημιουργεί η ομάδα. Αυτό το σήμα θεωρείται απλώς ως η μεταφορά αυτού του σταδίου. Το μαύρο κελί περιλαμβάνει τέσσερις εισόδους και δύο εξόδους. Οι είσοδοι για αυτό το κελί είναι τα σήματα P & G του παρόντος σταδίου και τα σήματα P, G από το προηγούμενο στάδιο.
Μια λογική PG περιλαμβάνει πύλες AND & XOR όπου η λογική πύλη AND χρησιμοποιείται για τη δημιουργία του σήματος G και η λογική πύλη XOR παρέχει το σήμα P. Για την εξάλειψη των περιττών μετατροπέων, χρησιμοποιούνται δύο είδη γκρι κυψελών και μαύρων κυψελών. Οι πύλες αντιστροφής που χρησιμοποιούνται σε μια σειρά για το γκρι κελί είναι AOI ή AND-OR-Inverter και οι πύλες αναστροφής για το μαύρο κελί στην επόμενη σειρά χρησιμοποιούν OAI ή OR-AND-Inverter. Το κελί AOI χρησιμοποιεί τις κανονικές εισόδους για να παρέχει ανεστραμμένες εξόδους ενώ το OAI χρησιμοποιεί ανεστραμμένες εισόδους για να παρέχει κανονικές εξόδους.
Λειτουργία αθροιστή Brent Kung
Ο αθροιστής Brent Kung είναι ένας παράλληλος αθροιστής προθέματος που χρησιμοποιείται για τη λειτουργία προσθήκης υψηλής απόδοσης. Αυτός ο αθροιστής μοιάζει με δομή δέντρου που εκτελεί την αριθμητική πράξη. Αυτός ο αθροιστής περιλαμβάνει μαύρα κελιά και γκρι κελιά. Κάθε μαύρο κελί έχει δύο πύλες ΚΑΙ και μία πύλη OR και κάθε γκρι κελί έχει μόνο μία πύλη ΚΑΙ.
Ο αθροιστής Brent-kung περιλαμβάνει δύο στάδια. το στάδιο προεπεξεργασίας και το στάδιο παραγωγής. Στο πρώτο στάδιο, η παραγωγή και η διάδοση θα γίνεται από κάθε ζεύγος εισόδων. Εδώ το propagate παρέχει μια λειτουργία «XOR» για τα bit εισόδου, ενώ η παραγωγή παρέχει μια λειτουργία «AND» για τα bit εισόδου. Η διάδοση και η δημιουργία τύπου «Pi» και «Gi» δίνονται παρακάτω.
Pi = Ai XOR Bi και Gi = Ai AND Bi.
Στο δεύτερο στάδιο, η μεταφορά θα δημιουργηθεί για κάθε δυαδικό ψηφίο που είναι γνωστό ως «Cg» και η μεταφορά διαδίδεται για κάθε δυαδικό ψηφίο που είναι γνωστό ως «Cp» παραγωγής. Για την περαιτέρω λειτουργία, θα δημιουργηθεί η διάδοση μεταφοράς και η δημιουργία φέρων. Το τελικό κελί που είναι διαθέσιμο σε κάθε λειτουργία bit παρέχει μεταφορά. Έτσι η μεταφορά του τελευταίου bit θα βοηθήσει στο άθροισμα του επόμενου bit ταυτόχρονα μέχρι το τελευταίο bit. Η μεταφορά παραγωγής & διάδοσης δίνονται ως:
Cp = P1 ΚΑΙ P0 και Cg=G1 OR (P1 ΚΑΙ G0)
Χρησιμοποιείται κυρίως για τη λειτουργία πρόσθεσης δύο τριάντα δύο bit & κάθε bit βιώνει το στάδιο προεπεξεργασίας & το στάδιο παραγωγής και μετά παρέχει το τελικό άθροισμα.
Τα κύρια bit εισόδου πηγαίνουν κάτω από το στάδιο προεπεξεργασίας και παράγουν διάδοση και παραγωγή. Έτσι, αυτά διαδίδονται καθώς και παράγουν υποβάλλονται σε στάδιο παραγωγής γεννά παράγει μεταφορά παράγει & μεταφορά διαδίδεται και παρέχει τελικό άθροισμα. Η διαδικασία αθροιστή Brent-kung βήμα προς βήμα φαίνεται παρακάτω.
Η διάταξη αθροιστή Brent-kung μοιάζει με δομή δέντρου και είναι ο αθροιστής υψηλής ταχύτητας που στοχεύει στη λογική σε επίπεδο πύλης. Αυτός ο αθροιστής μπορεί να σχεδιαστεί με μείωση του αριθμού των λογικών πυλών. Έτσι, μειώνει την καθυστέρηση και τη μνήμη που χρησιμοποιείται σε αυτήν την αρχιτεκτονική.
Brent Kung Adder Verilog Code
Ο κωδικός verilog του αθροιστή Brent Kung φαίνεται παρακάτω.
`define INPUTSIZE 64 //ρυθμίστε το μέγεθος εισόδου n
`καθορίστε το GROUPSIZE 8 //ορίστε το μέγεθος της ομάδας = 1, 2, 4 ή 8
ενότητα Brent_Kung_Adder(A, B, S);
είσοδος [`INPUTSIZE – 1:0] A;
είσοδος [`INPUTSIZE – 1:0] B;
έξοδος [`INPUTSIZE:0] S;
καλώδιο [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
σύρμα [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
σύρμα [`INPUTSIZE / `GROUPSIZE:0] cin;
σύρμα [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
εκχώρηση cin[0] = 1'b0;
παράγω
που μέσα?
για (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) ξεκινά: parallel_FA_CLA_prefix
group_q_generation #(.Groupsize(`GROUPSIZE))
φά(
.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])
)
τέλος
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])
)
για (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) ξεκινά: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1'b0),
.cin(cin[i + 1])
)
τέλος
εκχώρηση S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
δημιουργώ
endmodule
// Πρώτο μισό δέντρου παράλληλου προθέματος
module parallel_prefix_tree_first_half #(παράμετρος Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
είσοδος [Μέγεθος δέντρου * 2 – 1:0] q;
έξοδος [Μέγεθος δέντρου * 2 – 1:0] r;
παράγω
που μέσα?
εάν (Μέγεθος δέντρου == 2) ξεκινά: trivial_case
εκχωρήστε r[1:0] = q[1:0];
prefix_logic f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
)
τέλος άλλο αρχίζει: recursive_case
σύρμα [Μέγεθος δέντρου * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_lsbh(
.q(q[Μέγεθος δέντρων – 1:0]),
.r(r_temp[Μέγεθος δέντρων – 1:0])
)
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_msbh(
.q(q[Μέγεθος δέντρου * 2 – 1:Μέγεθος δέντρου]),
.r(r_temp[Μέγεθος δέντρου * 2 – 1:Μέγεθος δέντρου])
)
για (i = 0; i < Μέγεθος δέντρων * 2; i = i + 2) ξεκινούν: parallel_stitch_up
if (i != Μέγεθος δέντρων * 2 – 2) ξεκινά: parallel_stitch_up_pass
αντιστοιχίστε r[i + 1:i] = r_temp[i + 1:i];
τέλος άλλο αρχίζει: parallel_stitch_up_produce
prefix_logic f(
.ql(r_temp[Treesize – 1:Treesize – 2]),
.qh(r_temp[Μέγεθος δέντρων * 2 – 1:Μέγεθος δέντρων * 2 – 2]),
.r(r[Μέγεθος δέντρου * 2 – 1:Μέγεθος δέντρου * 2 – 2])
)
τέλος
τέλος
τέλος
δημιουργώ
endmodule
// Δεύτερο μισό δέντρου παράλληλου προθέματος
module parallel_prefix_tree_second_half #(παράμετρος Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
είσοδος [Μέγεθος δέντρου * 2 – 1:0] q;
έξοδος [Μέγεθος δέντρου * 2 – 1:0] r;
σύρμα [Μέγεθος δέντρου * 2 * ($clog2(Μέγεθος δέντρου) – 1) – 1:0] r_temp;
εκχώρηση r_temp[Μέγεθος δέντρων * 2 – 1:0] = q[Μέγεθος δέντρων * 2 – 1:0];
παράγω
genvar i, j;
για (i = 0; i < $clog2(Treesize) – 2; i = i + 1) ξεκινούν: second_half_level
εκχώρηση r_temp[Μέγεθος δέντρου * 2 * (i + 1) + ((Μέγεθος δέντρου / (2 ** i)) – 1 – 2 ** ($clog2(Μέγεθος δέντρου / 4) – i)) * 2 – 1:Μέγεθος δέντρου * 2 * (i + 1)] = r_temp[Μέγεθος δέντρου * 2 * i + ((Μέγεθος δέντρου / (2 ** i)) – 1 – 2 ** ($clog2(Μέγεθος δέντρου / 4) – i)) * 2 – 1: Μέγεθος δέντρου * 2 * i];
για (j = (Μέγεθος δέντρου / (2 ** i)) – 1 – 2 ** ($clog2(Μέγεθος δέντρου / 4) – i); j < Μέγεθος δέντρου; j = j + 2 ** ($clog2(Μέγεθος δέντρου / 2 ) – i)) έναρξη: second_half_level_logic
prefix_logic f(
.ql(r_temp[Μέγεθος δέντρου * 2 * i + (j – 2 ** ($clog2(μέγεθος δέντρου / 4) – i)) * 2 + 1:μέγεθος δέντρου * 2 * i + (j – 2 ** ($clog2( Μέγεθος δέντρου / 4) – i)) * 2]),
.qh(r_temp[Μέγεθος δέντρων * 2 * i + j * 2 + 1: Μέγεθος δέντρου * 2 * i + j * 2]),
.r(r_temp[Μέγεθος δέντρου * 2 * (i + 1) + j * 2 + 1: Μέγεθος δέντρου * 2 * (i + 1) + j * 2])
)
if (j != Μέγεθος δέντρων – 1 – 2 ** ($clog2(Treesize / 4) – i)) ξεκινά: second_half_level_direct_connect
εκχώρηση r_temp[Μέγεθος δέντρου * 2 * (i + 1) + (j + 2 ** ($clog2(Μέγεθος δέντρου / 2) – i)) * 2 – 1:Μέγεθος δέντρου * 2 * (i + 1) + j * 2 + 2] = r_temp[Μέγεθος δέντρων * 2 * i + (j + 2 ** ($clog2(Μέγεθος δέντρου / 2) – i)) * 2 – 1:Μέγεθος δέντρου * 2 * i + j * 2 + 2];
τέλος
τέλος
εκχωρήστε r_temp[Μέγεθος δέντρου * 2 * (i + 2) – 1:Μέγεθος δέντρου * 2 * (i + 2) – (2 ** ($clog2(Μέγεθος δέντρου / 4) – i)) * 2] = r_temp[Μέγεθος δέντρου * 2 * (i + 1) – 1:Μέγεθος δέντρων * 2 * (i + 1) – (2 ** ($clog2(Μέγεθος δέντρων / 4) – i)) * 2];
τέλος
εκχώρηση r[1:0] = r_temp[Μέγεθος δέντρων * 2 * ($clog2(Μέγεθος δέντρου) – 2) + 1:Μέγεθος δέντρου * 2 * ($clog2(Μέγεθος δέντρου) – 2)];
για (i = 1; i < Μέγεθος δέντρων; i = i + 2) αρχίζουν: final_r_odd
αντιστοιχίστε r[i * 2 + 1:i * 2] = r_temp[Μέγεθος δέντρου * 2 * ($clog2(Μέγεθος δέντρου) – 2) + i * 2 + 1:Μέγεθος δέντρου * 2 * ($clog2(Μέγεθος δέντρου) – 2) + i * 2];
τέλος
για (i = 2; i < Μέγεθος δέντρων; i = i + 2) αρχίζουν: final_r_even
prefix_logic f(
.ql(r_temp[Μέγεθος δέντρου * 2 * ($clog2(Μέγεθος δέντρου) – 2) + i * 2 – 1:Μέγεθος δέντρου * 2 * ($clog2(Μέγεθος δέντρου) – 2) + i * 2 – 2]),
.qh(r_temp[Μέγεθος δέντρου * 2 * ($clog2(Μέγεθος δέντρου) – 2) + i * 2 + 1:Μέγεθος δέντρου * 2 * ($clog2(Μέγεθος δέντρου) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
)
τέλος
δημιουργώ
endmodule
module group_q_generation #(παράμετρος Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
εισαγωγή [Groupsize – 1:0] a;
είσοδος [Μέγεθος ομάδας – 1:0] b;
είσοδος cin?
έξοδος [Groupsize – 1:0] s;
έξοδος [1:0] qg;
σύρμα [2 * Μέγεθος ομάδας – 1:0] q;
σύρμα [Groupsize – 1:0] c;
εκχωρήστε c[0] = cin;
παράγω
που μέσα?
για (i = 0; i < Μέγεθος ομάδας; i = i + 1) ξεκινά: parallel_FA_CLA_prefix
FA_CLA_πρόθεμα f(
.a(a[i]),
.b(b[i]),
.cin(c[i]),
.s(s[i]),
.q(q[i * 2 + 1:i * 2])
)
if (i != Groupsize – 1) ξεκινήσει: special_case
αντιστοιχίστε c[i + 1] = q[i * 2 + 1] | (q[i * 2] & c[i]);
τέλος
τέλος
//group q δημιουργία με βάση το Groupsize
εάν (Μέγεθος ομάδας == 1) ξεκινήσει: case_gs1
εκχώρηση qg[1] = q[1];
εκχώρηση qg[0] = q[0];
τέλος αλλιώς αν (Groupsize == 2) αρχίζει: case_gs2
εκχωρήστε qg[1] = q[3] | (q[1] & q[2]);
εκχώρηση qg[0] = q[2] & q[0];
τέλος αλλιώς αν (Groupsize == 4) αρχίζει: case_gs4
εκχωρήστε qg[1] = q[7] | (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
εκχώρηση qg[0] = q[6] & q[4] & q[2] & q[0];
τέλος αλλιώς αν (Groupsize == 8) αρχίζει: case_gs8
εκχωρήστε qg[1] = q[15] | (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]);
εκχωρήστε qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
τέλος
δημιουργώ
endmodule
// Λογική παραγωγής Cin
ενότητα cin_generation_logic(r, c0, cin);
είσοδος [1:0] r;
είσοδος c0;
cin εξόδου?
εκχωρήστε cin = (r[0] & c0) | r[1];
endmodule
// Βασική λογική για λειτουργίες προθέματος
module prefix_logic(ql, qh, r);
είσοδος [1:0] ql;
είσοδος [1:0] qh;
έξοδος [1:0] r;
εκχώρηση r[0] = qh[0] & ql[0];
εκχωρήστε r[1] = (qh[0] & ql[1]) | qh[1];
endmodule
// Πλήρες κελί αθροιστή με Carry Look-Ahead
ενότητα FA_CLA_prefix(a, b, cin, s, q);
είσοδος a;
είσοδος β;
είσοδος cin?
έξοδος s;
έξοδος [1:0] q;
εκχωρήστε q[0] = a ^ b;
εκχωρήστε s = q[0] ^ cin;
εκχώρηση q[1] = a & b;
endmodule
Πλεονεκτήματα
Τα πλεονεκτήματα του Brent Kung Adder περιλαμβάνουν τα ακόλουθα.
- Αυτός είναι ένας αθροιστής χαμηλής ισχύος επειδή χρησιμοποιεί ένα ελάχιστο κύκλωμα για να πάρει το αποτέλεσμα.
- Είναι ένας πολύ δημοφιλής και ευρέως χρησιμοποιούμενος αθροιστής.
- Αυτό το είδος αθροιστή μπορεί να υλοποιηθεί χρησιμοποιώντας λιγότερες μονάδες σε σύγκριση με έναν αθροιστή Kogge-Stone.
- Ο σχεδιασμός του αθροιστή Brent-Kung είναι πολύ εύκολος.
- Αυτός ο αθροιστής έχει λιγότερες συνδέσεις με άλλες μονάδες.
- Αυτοί οι αθροιστές προτάθηκαν κυρίως για την επίλυση των μειονεκτημάτων των αθροιστών Kogge-Stone.
Μειονεκτήματα
ο μειονεκτήματα του Brent Kung Adde r περιλαμβάνουν τα ακόλουθα.
- Αυτοί οι αθροιστές έχουν μεγαλύτερη καθυστέρηση και χρειάζονται 2 log2 n − 2 λογικά επίπεδα για τον υπολογισμό όλων των δυαδικών ψηφίων μεταφοράς.
- Το κύριο μειονέκτημα αυτού του αθροιστή είναι το fanout που μπορεί να προκαλέσει τη διάδοση του ρεύματος σε όλο τον αθροιστή να χωριστεί και να γίνει πιο αδύναμο.
Εφαρμογές Brent Kung Adder
Οι εφαρμογές του Brent Kung Adder περιλαμβάνουν τα ακόλουθα.
- Ένας αθροιστής Brent–Kung χρησιμοποιείται με τρόπο σωλήνωσης για τη μείωση της κατανάλωσης ισχύος μειώνοντας το συνδυαστικό λογικό βάθος και τη σταθεροποίηση των δυσλειτουργιών.
- Ο αθροιστής Brent-Kung παρέχει έναν εξαιρετικό αριθμό σταδίων από i/p σε όλα τα o/ps αλλά με ασύμμετρη φόρτωση ενδιάμεσων σταδίων.
- Αυτός ο αθροιστής μπορεί να χρησιμοποιηθεί εντός του πολλαπλασιαστή καθώς και σε άλλα στοιχεία διαδρομής δεδομένων.
Έτσι, αυτό είναι μια επισκόπηση του Brent kung adder , τη λειτουργία του, τα πλεονεκτήματα, τα μειονεκτήματα και τις εφαρμογές του. Αυτός είναι ένας πολύ αποδοτικός αθροιστής και η δομή του μοιάζει με δομή δέντρου που χρησιμοποιείται κυρίως για αριθμητικές πράξεις υψηλής απόδοσης. Αυτός ο τύπος αθροιστή είναι πολύ γρήγορος και εστιάζει κυρίως στη λογική του επιπέδου πύλης. Αυτός ο αθροιστής έχει σχεδιαστεί χρησιμοποιώντας λιγότερο αριθμό λογικών πυλών. Έτσι, μειώνει τη μνήμη και την καθυστέρηση που χρησιμοποιείται σε αυτήν την αρχιτεκτονική. Εδώ είναι μια ερώτηση για εσάς, Brent kung adder γνωστό και ως;
