Ключевые слова: блокирующее присваивание, неблокирующее присваивание, параллельность
Процедурное присваивание — это присваивание внутри блока операторов initial или always, а объектами присваивания являются такие типы, как регистры, целые, вещественные и т. д.
После присваивания этим переменным их значения остаются неизменными, пока им снова не будут присвоены новые значения.
Непрерывное присваивание всегда активно; любое изменение операнда влияет на результат выражения. Процедурное присваивание вступает в силу только при выполнении оператора. В этом разница между непрерывным и процедурным присваиванием.
Процедурное присваивание в Verilog включает два типа операторов: блокирующее присваивание и неблокирующее присваивание.
Блокирующее присваивание
Блокирующее присваивание — это последовательное выполнение, означающее, что до выполнения следующего оператора текущий оператор должен быть завершён.
Операторы блокирующего присваивания используют знак равенства=в качестве оператора присваивания.
В предыдущих симуляциях операторы присваивания в блоках initial все использовали блокирующее присваивание.
Неблокирующее присваивание
Неблокирующее присваивание — это оператор параллельного выполнения, означающий, что следующий оператор выполняется одновременно с текущим оператором; он не блокирует выполнение последующих операторов в том же блоке.
Операторы неблокирующего присваивания используют знак «меньше или равно»<=в качестве оператора присваивания.
Используйте следующий код для моделирования блокирующего и неблокирующего присваивания, чтобы проиллюстрировать разницу между двумя процедурными присваиваниями.
Пример
module test ;
reg [3:0] ai, bi ;
reg [3:0] ai2, bi2 ;
reg [3:0] value_blk ;
reg [3:0] value_non ;
reg [3:0] value_non2 ;
initial begin
ai = 4'd1 ; //(1)
bi = 4'd2 ; //(2)
ai2 = 4'd7 ; //(3)
bi2 = 4'd8 ; //(4)
#20 ; //(5)
//неблокирующее присваивание с блокирующим присваиванием
ai = 4'd3 ; //(6)
bi = 4'd4 ; //(7)
value_blk = ai + bi ; //(8)
value_non <= ai + bi ; //(9)
//само неблокирующее присваивание
ai2 <= 4'd5 ; //(10)
bi2 <= 4'd6 ; //(11)
value_non2 <= ai2 + bi2 ; //(12)
end
//остановить моделирование
always begin
#10 ;
if ($time >= 1000) $finish ;
end
endmodule
Результаты моделирования следующие:
Операторы (1)-(8) — все блокирующие присваивания и выполняются последовательно.
До 20ns значения сигналов ai и bi изменяются. Из-за особенностей процедурного присваивания value_blk = ai + bi ещё не было выполнено, поэтому до 20ns значение value_blk равно X (неизвестное состояние).
Через 20ns значения сигналов ai и bi снова изменяются. Когда выполняется value_blk = ai + bi, сигнал value_blk использует новые значения сигналов ai и bi и получает результат вычисления 7.
Операторы (9)-(12) — все являются неблокирующими присваиваниями и выполняются параллельно.
Во-первых, хотя (9)-(12) выполняются одновременно, порядок их выполнения всё ещё после (8), поэтому когда вычисляется сигнал value_non = ai + bi, он также использует новые значения сигналов ai и bi, в результате получается 7.
Во-вторых, (10)-(12) выполняются одновременно, поэтому при вычислении value_non2 = ai2 + bi2 он не учитывает последние результаты неблокирующих присваиваний сигналов ai2 и bi2. То есть value_non2 использует старые значения сигналов ai2 и bi2, и результат равен 4'hF.

Используйте неблокирующее присваивание, чтобы избежать состояний гонки
Приведённый выше код моделирования предназначен только для того, чтобы помочь читателям лучше понять разницу между блокирующими и неблокирующими присваиваниями. В реальном проектировании на Verilog помните, что нельзя смешивать блокирующие и неблокирующие присваивания в одной и той же процедурной конструкции. Когда эти два стиля присваивания смешиваются, трудно контролировать временные соотношения, и легко могут возникнуть неожиданные результаты.
Чаще всего при проектировании схем неблокирующее присваивание в основном используется в always-блоках последовательностной логики, а блокирующее присваивание — в основном в always-блоках комбинационной логики. При моделировании схем блокирующее присваивание обычно используется в initial-блоках.
Как показано ниже, чтобы реализовать функцию обмена значениями двух регистров по переднему фронту тактового сигнала, блокирующее присваивание используется в двух always-блоках.
Поскольку операторы в двух always-блоках выполняются одновременно, но порядок выполнения a=b и b=a невозможно определить, это создаёт состояние гонки.
Но независимо от того, что выполнится первым (это зависит от компилятора и т. п.), если не учитывать вопросы синхронизации, порядок их выполнения всегда последовательный, и в итоге значения a и b всегда равны. Эффект обмена значениями двух регистров не достигается.
Пример
a = b ;
end
always @(posedge clk) begin
b = a;
end
Однако если в блоках always используется неблокирующее присваивание, описанной выше гонки можно избежать.
Как показано ниже, операторы в двух блоках always выполняются параллельно. Операнды в правой части присваивания используют старые значения из предыдущего такта. В этот момент a<=b и b<=a могут выполняться, не мешая друг другу, что позволяет обменять значения регистров.
Пример
a <= b ;
end
always @(posedge clk) begin
b <= a;
end
Конечно, следующий код также может реализовать функцию обмена значениями регистров, но он явно не так прост и интуитивно понятен, как прямое использование неблокирующего присваивания в блоках always.
Пример
temp = a ;
a = b ;
b = temp ;
end
Скачать исходный код
Скачать