понимание двоичного множителя с использованием диаграммы уровня затвора

Question

понимание двоичного множителя с использованием диаграммы уровня затвора

Если вы используете ORM, попробуйте функцию with_for_update :

foo = session.query(Foo).filter(Foo.id==1234).with_for_update().one()
# this row is now locked

foo.name = 'bar'
session.add(foo)

session.commit()
# this row is now unlocked

2

multiplication synthesis binary verilog fpga

задан kevin998x 18 January 2019 в 15:48

1 ответ

Другие вопросы по тегам:

multiplication synthesis binary verilog fpga

Похожие вопросы:

score 0 · Answer 1

Замечание о MUX

Напомним, что ? описывает мультиплексор (MUX), поэтому утверждение:

out = sel ? x : y

эквивалентен в реализации уровня шлюза:

out = (sel & x) | (~sel & y)

(когда sel=1, out <= x, когда sel=0, out <= y)

Если y=0, то MUX сводится к И между x и sel: out = (sel & x) | (~sel & 0) = sel & x

Получение w_r

Предполагая BW=2 и [1112 ] w_r - это 4-битный сигнал. Давайте разберемся с этим:

w_r = w_rL ^ x_rR

w_rL = { ((i_a[1])?i_b:{(BW){1'b0}}), 1'b0 }

w_rR = { 1'b0, ((i_a[0])?i_b:{(BW){1'b0}}) }

Обратите внимание, что оба значения «else» MUX равны нулю ', то MUX упрощены до AND, как в примечании выше:

w_rL = { BW{i_a[1]} & i_b, 1'b0 } = { A1 & B1, A1 & B0, 0 }

w_rR = { 1'b0, BW{i_a[0]} & i_b } = { 0, A0 & B1, A0 & B0}

[1168]

Я заменил i_a = {A1, A0} и i_b = {B1, B0} упростить представление. В конце концов, путем их XORing по битам:

w_r[0] = 0 ^ (A0 & B0) = A0 & B0
w_r[1] = (A1 & B0) ^ (A0 & B1) [1122]
[1171]
1123]
w_r[3] = 0 (устанавливается неявно)

Получение c

Аналогично для 1-битный сигнал c:

c = cL & cR

cL = i_a[1] ? i_b[(BW-2):0]:{(BW-1){1'b0}} = {A1 & B0}

cR = i_a[0] ? i_b[(BW-1):1]:{(BW-1){1'b0}} = {A0 & B1) [1128]

В конце концов:

c = {A1 & B0 & A0 & B1}

Получение o_r

Если разбить o_r битов:

o_r[0] = 0 + w_r[0] = A0 & B0
o_r[1] = 0 + w_r[1] = (A1 & B0) ^ (A0 & B1)
o_r[2] = c + w_r[2] = (A1 & B0 & A0 & B1) + (A1 & B1) - если мы добавим их, то сумма будет их XOR, и перенос это их И, то есть: o_r[2] = (A1 & B0 & A0 & B1) ^ (A1 & B1)
o_r[3] = <carry from o_r[2] addition> = A1 & B0 & A0 & B1 & A1 & B1 = A1 & B0 & A0 & B1 (помните, ANDing с собой равняется самому себе, то есть x & x = x)

Вывод диаграммы уровня шлюза

Ваша диаграмма уровня шлюза отображает следующие уравнения:

C0 = A0 & B0 (=o_r[0])

C1 = (A0 & B1) ^ (A1 & B0) (=o_r[1])

C2 = (A0 & B1 & A1 & B0) ^ (A1 & B1) (=o_r[2] сумма)

C3 = (A0 & B1 & A1 & B0) & (A1 & B1) = A0 & B1 & A1 & B0 (=o_r[3] переносить)

Почему реализация такая странная?!

Комментарии к коду указывают, что ячейка умножителя построена для конкретной архитектуры FPGA, и похоже, что намерение исходного кодера было чтобы соответствовать каждой ячейке множителя в одной LUT для этой архитектуры. Поэтому я держу пари, что оригинальный кодер пытался «направить» старый, тупой инструмент на построение множителя эффективным с точки зрения ПЛИС способом, который обычно не эффективен на уровне затвора. Я думаю, что такие «ручные» оптимизации уровня RTL бесполезны с сегодняшними инструментами EDA (надеюсь!).