Сумматор Брента-Кунга был предложен в 1982 году Сян Те Кунгом и Ричардом Пирсом Брентом. Это сумматор параллельных префиксов или сумматор деревьев, который широко используется в цифровом дизайне благодаря своей гибкости. Параллельные сумматоры префиксов могут быть построены несколькими способами в зависимости от количества логических уровней. логические элементы задействованы разветвления от каждых ворот и проводка между уровнями. Доступны различные типы древовидных сумматоров, основными древесными сумматорами являются Скланским Когге-Стоун и Брент-Кунг. По сравнению с KSA (сумматор Когге-Стоуна), этот сумматор обеспечивает высокую регулярность структуры сумматора и имеет меньшее количество блокировок проводки. что приводит к повышению производительности и уменьшению требуемой площади чипа. В этой статье представлена краткая информация о Брент Кунг Аддер .
Что такое Брент Кунг Аддер?
Сумматор, который использует минимум схем для получения результата, известен как сумматор Брента Кунга, а также известен как сумматор малой мощности или параллельный сумматор. Этот сумматор предназначен для экономии размера микросхемы, чтобы упростить изготовление этих сумматоров. Симметрия и обычная структура этого сумматора значительно снизят производственные затраты и их можно использовать в конвейерных топологиях. Использование комплементарной транзисторной логики помогает улучшить производительность конструкции. мультиплексор подход в различных конструкциях ячеек.
Трасса Брента Кунга Аддера
Ниже показана диаграмма сумматора параллельных префиксов Брент-Кунга, которая включает этап 1 (этап предварительной обработки), этапы со 2 по 7 — этапы генерации переноса и этап 8 — постобработку. Это усовершенствованная архитектура, очень простая в построении и обеспечивающая меньшую перегрузку проводки. Таким образом, меньшее количество проводов уменьшит объем необходимого пространства для реализации архитектуры. Кроме того, прокладка значительно упрощается за счет пересечения (или) перекрытия меньшего количества проводов. Однако штраф за задержку увеличится из-за увеличения количества каскадов. Разветвление для этого сумматора увеличивается, а затем увеличивается и задержка.
Как работает гадюка Брента Кунга?
Brent Kung Adder работает путем вычисления префиксов для двух битовых групп, что полезно при поиске префиксов 4-битных групп. Эти префиксы используются для вычисления префиксов 8-битной группы и т. д. После этого эти префиксы будут использоваться для вычисления выполнения конкретной битовой стадии. Эти переносы используются с групповым распространением следующего этапа для вычисления бита суммы этого этапа. Брент Кунг Три использует 2log2N – 1 этап.
32-битный Брент Кунг Аддер
Схема 32-битного сумматора Брента Куна показана ниже. В начале этой схемы проектируются базовые логические элементы, такие как NAND, инвертор, XOR, NOR и т. д. После этого необходимые ячейки, такие как черные ячейки, серые ячейки, буферы и логика PG, проектируются с использованием логических элементов.
В приведенном ниже 32-битном сумматоре Брента Кунга инвертирующие элементы, такие как AOI и OAI, поочередно используются в основном для серых и черных ячеек. Таким образом, черные и серые ячейки представлены серыми и черными блоками, а буферы — кружками.
Входы типа A и B подаются на логику PG, которая показана на блок-схеме. Для 32-битного сумматора необходимы 32 логических блока PG, а сигналы распространения (P) и генерации (G) являются выходами этого блока. Эти сигналы передаются в древовидную структуру сумматора Брента Кунга. В структуру этого сумматора входят серые и черные ячейки.
Серая ячейка включает три входа и один выход. Распространение и генерация сигналов с текущего этапа и генерация сигналов с предыдущего этапа являются входами, тогда как группа генерирующих сигналов является O/P. В любой древовидной структуре каждый этап заканчивается серой ячейкой, и выходной сигнал этой ячейки является сигналом генерации группы. Этот сигнал рассматривается просто как перенос этого этапа. Черная ячейка имеет четыре входа и два выхода. Входными данными для этой ячейки являются сигналы P и G текущего этапа и сигналы P, G предыдущего этапа.
Логика PG включает в себя вентили AND и XOR, где логический вентиль AND используется для генерации сигнала G, а логический вентиль XOR обеспечивает сигнал P. Чтобы исключить ненужные инверторы, используются два типа серых и черных ячеек. Инвертирующие элементы, используемые в одной строке для серой ячейки, представляют собой AOI или И-ИЛИ-инвертор, а инвертирующие элементы для черной ячейки в следующей строке используют OAI или ИЛИ-И-инвертор. Ячейка AOI использует обычные входные данные для обеспечения инвертированных выходных данных, тогда как OAI использует инвертированные входные данные для обеспечения нормальных выходных данных.
Операция Брента Кунга Аддера
Сумматор Брента Кунга — это параллельный сумматор префиксов, используемый для операций высокопроизводительного сложения. Этот сумматор выглядит как древовидная структура, выполняющая арифметические операции. Этот сумматор включает черные и серые ячейки. Каждая черная ячейка имеет два вентиля И и один вентиль ИЛИ, а каждая серая ячейка имеет только один вентиль И.
Сумматор Брент-кунга включает в себя два каскада; этап предварительной обработки и этап генерации. На первом этапе генерация и распространение будут осуществляться из каждой пары входов. Здесь распространение обеспечивает операцию «исключающее ИЛИ» для входных битов, тогда как генерирование обеспечивает операцию «И» для входных битов. Распространение и генерация типа «Пи» и «Ги» приведены ниже.
Pi = Ai XOR Bi и Gi = Ai AND Bi.
На втором этапе перенос будет генерироваться для каждого бита, который известен как перенос, генерирующий «Cg», и перенос распространяется для каждого бита, известный как перенос, генерирующий «Cp». Для дальнейшей работы будут сгенерированы переносы распространения и переноса генерации. Последняя ячейка, доступная в каждом бите, обеспечивает перенос. Таким образом, перенос последнего бита поможет суммировать следующий бит одновременно до последнего бита. Генерация и распространение переноса задаются как;
Cp = P1 И P0 и Cg=G1 ИЛИ (P1 И G0)
Он используется в основном для операции сложения двух тридцати двух битов, и каждый бит проходит стадию предварительной обработки и стадию генерации, а затем дает окончательную сумму.
Первичные входные биты идут ниже стадии предварительной обработки и производят распространение и генерацию. Таким образом, они распространяются, а также генерируются, проходят стадию генерации, генерируют, генерируют, перенос распространяется и дают окончательную сумму. Пошаговый процесс работы сумматора Брент-кунга показан ниже.
Сумматор Брент-кунга выглядит как древовидная структура и представляет собой высокоскоростной сумматор, ориентированный на логику уровня вентиля. Этот сумматор может быть спроектирован с уменьшением количества логических элементов. Таким образом, это уменьшает задержку и память, используемую в этой архитектуре.
Брент Кунг Аддер Verilog Code
Верилог-код сумматора Брента Кунга показан ниже.
`define INPUTSIZE 64 //устанавливаем размер ввода n
`define 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;
генерировать
в которой;
for (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])
);
for (i = 0; i
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1’b0),
.cin(cin[i + 1])
);
конец
назначить S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
порождать
конечный модуль
// Первая половина параллельного дерева префиксов
модуль Parallel_prefix_tree_first_half #(параметр Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
ввод [Размер дерева * 2 – 1:0] q;
вывод [Размер дерева * 2 – 1:0] r;
генерировать
в которой;
если (Treesize == 2) начало: tribution_case
назначить r[1:0] = q[1:0];
prefix_logic f(
.ql(д[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
конец еще начало: recursive_case
провод [Treesize * 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:Размер дерева])
);
for (i = 0; i < Treesize * 2; i = i + 2) начало:параллельный_stitch_up
if (i != Treesize * 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[Размер дерева – 1:Размер дерева – 2]),
.qh(r_temp[Размер дерева * 2 – 1:Размер дерева * 2 – 2]),
.r(r[Размер дерева * 2 – 1:Размер дерева * 2 – 2])
);
конец
конец
конец
порождать
конечный модуль
// Вторая половина параллельного дерева префиксов
модуль Parallel_prefix_tree_ Second_half #(параметр Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
ввод [Размер дерева * 2 – 1:0] q;
вывод [Размер дерева * 2 – 1:0] r;
провод [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
назначить r_temp[Treesize * 2 – 1:0] = q[Treesize * 2 – 1:0];
генерировать
генвар я, j;
for (i = 0; i < $clog2(Treesize) – 2; i = i + 1) начало: Second_half_level
назначить r_temp[Treesize * 2 * (i + 1) + ((Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i)) * 2 – 1:Treesize * 2 * (i + 1)] = r_temp[Treesize * 2 * i + ((Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i)) * 2 – 1: Размер дерева * 2 * i];
for (j = (Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i); j < Treesize; j = j + 2 ** ($clog2(Treesize / 2) ) – i)) начало: 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( Размер дерева / 4) – i)) * 2]),
.qh(r_temp[Treesize * 2 * i + j * 2 + 1:Treesize * 2 * i + j * 2]),
.r(r_temp[Размер дерева * 2 * (i + 1) + j * 2 + 1:Размер дерева * 2 * (i + 1) + j * 2])
);
if (j != Treesize – 1 – 2 ** ($clog2(Treesize / 4) – i)) начало: Second_half_level_direct_connect
назначить r_temp[Treesize * 2 * (i + 1) + (j + 2 ** ($clog2(Treesize / 2) – i)) * 2 – 1:Treesize * 2 * (i + 1) + j * 2 + 2] = r_temp[Treesize * 2 * i + (j + 2 ** ($clog2(Treesize / 2) – i)) * 2 – 1:Treesize * 2 * i + j * 2 + 2];
конец
конец
назначить r_temp[Treesize * 2 * (i + 2) – 1:Treesize * 2 * (i + 2) – (2 ** ($clog2(Treesize / 4) – i)) * 2] = r_temp[Treesize * 2 * (i + 1) – 1:Treesize * 2 * (i + 1) – (2 ** ($clog2(Treesize / 4) – i)) * 2];
конец
назначить r[1:0] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + 1:Treesize * 2 * ($clog2(Treesize) – 2)];
for (i = 1; i < Treesize; i = i + 2) начало: Final_r_odd
назначить r[i * 2 + 1:i * 2] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + я*2];
конец
for (i = 2; i
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])
);
конец
порождать
конечный модуль
модуль group_q_generation #(параметр Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
ввод [Размер группы – 1:0] a;
ввод [Размер группы – 1:0] b;
ввод cin;
вывод [Размер группы – 1:0] с;
выход [1:0] qg;
проволока [2 * Размер группы – 1:0] q;
провод [Размер группы – 1:0] c;
назначить c[0] = cin;
генерировать
в которой;
for (i = 0; i <размер группы; i = i + 1) начало: Parallel_FA_CLA_prefix
FA_CLA_prefix f(
.а(а[я]),
.б(б[я]),
.cin(с[я]),
.s(с[я]),
.q(q[i * 2 + 1:i * 2])
);
if (i != Groupsize – 1) начало: Special_case
назначить c[i + 1] = q[i * 2 + 1] | (д[я * 2] и с[я]);
конец
конец
//генерация группы q на основе размера группы
if (Groupsize == 1) начало: case_gs1
назначить qg[1] = q[1];
назначить qg[0] = q[0];
конец else if (Groupsize == 2) начало: case_gs2
назначить qg[1] = q[3] | (д[1] и д[2]);
назначить qg[0] = q[2] и q[0];
end else if (Groupsize == 4) начать: case_gs4
назначить qg[1] = q[7] | (д[5] и д[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];
конец else if (Groupsize == 8) начало: case_gs8
назначить qg[1] = q[15] | (д[13] и д[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];
конец
порождать
конечный модуль
// Логика генерации Cin
модуль cin_generation_logic(r, c0, cin);
ввод [1:0] р;
вход с0;
выходной сигнал;
назначить cin = (r[0] & c0) | р[1];
конечный модуль
// Базовая логика для префиксных операций
модуль 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]) | дч[1];
конечный модуль
// Полная сумматорная ячейка с переносом вперед
модуль FA_CLA_prefix(a, b, cin, s, q);
введите а;
вход б;
ввод cin;
выход с;
выход [1:0] q;
назначить q[0] = a ^ b;
назначить s = q[0] ^ cin;
назначить q[1] = a и b;
конечный модуль
Преимущества
К преимуществам Brent Kung Adder можно отнести следующее.
- Это сумматор малой мощности, поскольку для получения результата он использует минимальную схему.
- Это очень популярный и широко используемый сумматор.
- Этот тип сумматора может быть реализован с использованием меньшего количества модулей по сравнению с сумматором Когге-Стоуна.
- Спроектировать сумматор Брента-Кунга очень просто.
- Этот сумматор имеет меньше связей с другими модулями.
- Эти сумматоры были предложены главным образом для устранения недостатков сумматоров Когге-Стоуна.
Недостатки
Недостатки Брента Кунг Адде r включают следующее.
- Эти сумматоры имеют большую задержку и требуют 2 log2 n - 2 логических уровня для вычисления всех битов переноса.
- Основным недостатком этого сумматора является разветвление, которое может привести к разделению и ослаблению тока, распространяющегося по сумматору.
Приложения Brent Kung Adder
Применения Брента Кунга Аддера включают следующее.
- Сумматор Брента-Кунга используется конвейерным способом для снижения энергопотребления за счет уменьшения комбинаторной логической глубины и стабилизации сбоев.
- Сумматор Брента-Кунга обеспечивает выдающееся количество ступеней от i/p до всех o/ps, но с асимметричной загрузкой промежуточных ступеней.
- Этот сумматор можно использовать в множителе, а также в других элементах пути данных.
Таким образом, это обзор сумматора Brent kung , его работа, преимущества, недостатки и применение. Это очень эффективный сумматор, и его структура выглядит как древовидная структура, используемая в основном для высокопроизводительных арифметических операций. Этот тип сумматора очень быстр и ориентирован в основном на логику уровня вентиля. Этот сумматор спроектирован с использованием меньшего количества логических элементов. Таким образом, это уменьшает объем памяти и задержку, используемые в этой архитектуре. Вот вопрос к тебе, гадюка Брента Кунга, также известная как?
