литература / 1sternkheym_e_proektirovanie_tsifrovykh_skhem_na_yazyke_opisa

Язык Verilog имеет много

управляющих

конструкций из других языков вы-

сокого уровня, особенно из языка Си.

ЦИКЛ FOR

Cледующий пример (рис.2.7)

показывает

использование цикла for.

Выполнение

модуля for_loop дает следующие результаты:

i

=

0

(0

в двоичном виде)

i

=

1

(1

в двоичном виде)

i =

2

(10

в

двоичном

виде)

i =

3

(11

в

двоичном

виде)

|

module for_loop

|

|

integer i;

|

|

|

|

initial

|

|

|

|

for (i = 0; i < 4; i = i + 1) begin

|

|

$display ("i = %0d (%b binary)", i, i);

|

|

end

|

|

endmodule

|

|

|

`---------------------------------------------------

Рис.2.7 Оператор цикла for

'

выбора. Оператор

выбора соответствует переключателю

switch языка Си.

,--------------------------------------------------.

|

module while_loop

|

|

integer i;

|

|

initial begin

|

|

i = 0;

|

|

while (i < 4) begin

|

|

$display ("i = %0d (%b binary)", i, i);|

|

i = i + 1;

|

|

end

|

|

end

|

|

endmodule

|

`--------------------------------------------------'

Рис.2.8 Оператор цикла while

,--------------------------------------.

|

module case_statement;

|

|

integer i;

|

|

initial i = 0;

|

|

always begin

|

|

$display ("i = %0d", i);

|

|

case (i)

|

|

0: i = i + 2;

|

|

1: i = i + 7;

|

|

2: i = i - 1;

|

|

default: $stop;

|

|

endcase

|

|

end

|

|

endmodule

|

`--------------------------------------'

Рис.2.9 Оператор выбора

Выбирающее выражение (в скобках) сравнивается со значениями (перед ":"),

совпадение будет при поразрядном совпадении (подобно оператору ===).

Если нет

совпадения

ни

с

одним

вариантом, выполняется

действие

по

несовпадению

(default).

по

несовпадению

не описано,

то продолжается

выполнение после

Если

действие

оператора

выбора.

Хорошим

программистским

тоном

является

всегда

описывать

действие при несовпадении. Если такое не может случиться,

то

модель

должна

печатать сообщение об ошибке или прекратить моделирование.

за

одним

исключе-

Операторы casez и casex очень похожи на

оператор

case,

нием. Оператор casez не обращает

внимание

на разряды,

находящиеся

в

состоянии

z,

а оператор casex не обращает

внимание

на

разряды, находящиеся

в

состоянии z

и x.

ЦИКЛ REPEAT

ми

В языке Verilog есть еще две управляющие

структуры,

не

являющиеся

обычны-

для других

языков

программирования. На

рис.2.10 показан

цикл repeat, кото-

рый ждет 5 тактов, а затем прекращает моделирование.

ЦИКЛ FOREVER

На рис.2.11 показан цикл forever, который следит за некоторым условием и

выдает сообщение, когда условие выполняется.

управ-

Хотя операторы repeat и forever можно реализовать с помощью других

ляющих операторов, например, с помощью

оператора for,

они

очень

удобны,

особенно при выдаче команд с

клавиатуры.

Их

преимущество

в

том,

что

они не

требуют описания переменных заранее.

,------------------------------------.

|

module repeat_loop (clock);

|

|

input clock;

|

|

initial begin

|

|

|

|

repeat (5)

|

|

@ (posedge clock);

|

|

$stop;

|

|

end

|

|

endmodule

|

|

|

`------------------------------------'

Рис.2.10 Цикл repeat

,----------------------------------------------------.

|

module forever_statement (a,b,c);

|

|

input a,b,c;

|

|

initial forever begin

|

|

|

|

@ (a or b or c)

|

|

if (a + b == c) begin

|

|

$display ("a(%d)+b(%d) = c(%d)", a,b,c);|

|

$stop;

|

|

end

|

|

end

|

|

endmodule

|

|

|

`----------------------------------------------------

'

наиболее важное различие – в

понятии времени и

его влиянии на

порядок выполне-

ния операторов в модуле.

В большинстве языков программирования существует

единственный

программный счетчик,

указывающий

текущее место

выполнения про-

граммы. Так

как в аппаратуре

все

элементы работают параллельно,

последователь-

зом, выполнение в Verilog управляется событиями. Глобальная переменная

обозна-

чает

модельное

время.

В

каждый

момент времени может быть одно или более собы-

тий,

которые

следует

выполнить.

Планировщик

событий

программы моделирова-

ния Verilog simulator занимает место программного счетчика

языков программиро-

вания.

simulator

выполняет

все

события,

запланированные

на

текущее мо-

Verilog

дельное время и удаляет их из

списка событий.

Когда

в

текущее

модельное

время нет больше событий, тогда

модельное время продвигается к первому элемен-

ту,

запланированному

на

следующий

раз.

По

мере выполнения

событий генериру-

ются

новые

события

для

будущего

времени (или,

возможно,

для текущего). На

рис.2.12 показана ось модельного времени с несколькими событиями,

запланиро-

ванными в

различных

точках. Заметим,

что время

перед текущим модельным вре-

менем

не

может иметь

никаких

событий,

связанных с ним,

так

как

все

события

были выполнены и удалены.

внутри

одного

и то же модельного времени, в

Порядок

выполнения

событий

общем случае, не известен и

нельзя полагаться нанего,

так

как Verilog

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

событий

особым образом. Однако,

Verilog

гарантирует, что

линейный

код, который

не

име-

будет одинаковым. Пример

на рис.2.13

иллюстрирует это использованием не-

скольких функциональных элементов.

текущее

t1

t2

t3

-----------,----------------,----------------,------->

время

|

|

|

,-----'-----.

,-----'-----.

,-----'-----.

| событие 0 |

| событие 3 |

| событие 4 |

`-----,-----'

`-----------'

`-----,-----'

,-----'-----.

,-----'-----.

| событие 1 |

| событие 5 |

`-----,-----'

`-----------'

,-----'-----.

| событие 2 |

`-----------'

|

module event_control;

|

|

register [4:0] r;

|

|

|

|

initial begin

|

|

|

|

$display ("First initial block, line 1.");

|

|

$display ("First initial block, line 2.");

|

|

end

|

|

initial

|

|

|

|

for (r = 0; r <= 3; r =r + 1)

|

|

$display ("r = %0b",r);

|

|

endmodule

|

|

|

`--------------------------------------------------------

'

Рис.2.13 Несколько функциональных элементов

Здесь видно,

что все блоки initial по плану

должны

выполняться в одно

и

то же модельное время (момент 0).

на

рис.2.13,

можно

видеть, что

Обращаясь к

результатам моделирования

Verilog выбирает некоторый порядок выполнения

блоков, который

не

очевиден

из

рассмотрения программы модели. Заметим, однако,

что

если блок

был

запланирован

к выполнению, он продолжает выполняться до полного окончания.

выполнение процесса на фиксированное время, указанное

параметром

"время", а

форма @событие-выражение, используемая для асинхронного

контроля ,

останавли-

планировщик

удаляет

исполняемые

в

настоящий момент события

из

списка событий

текущего модельного времени и заносит их в некоторый список будущих событий.

Форма

wait (выражение)

-

это управление

событиями,

чувствительное к

уровню. Если wait выражение

ложно,

выполнение

будет

остановлено до

тех

пор, пока

оно не

станет истинным (из-за выполнения

некоторого

оператора

в

другом процессе).

использование

структуры

управления време-

Пример на рис.2.14 показывает

нем.

Выполнение модуля time_control дает следующие результаты:

r = 2 в момент

5

r = 1 в момент

10

r = 2

в момент

25

r = 1

в момент

30

r = 2

в момент

55

r = 1

в момент

60

В

этом примере, хотя

все блоки initial

начинаются в один и

тот

же мо-

мент времени, некоторые из

них были остановлены(и

перепланированы) в

разные

моменты

модельного времени.

Обратите внимание

на

использование

именованных

переменных, хотя в

этом примере это свойство

не

используется,

а

имена ис-

пользуют только для удобства записи.

чтобы случилось событие, преж-

Форма управления @событие-выражение ждет,

де, чем продолжать

выполнение блока. Событие

может

быть одной

из

нескольких

В форме а)

выполнение задерживается до тех пор, пока одна из переменных

не изменится.

В форме b) и с) выполнение задерживается, пока

переменная не

изменится от 0,

х или z к

,-----------------------------------------------------.

|

module time_control;

|

|

reg[1:0] r;

|

|

|

|

initial #70 $stop;

|

|

|

|

initial begin : b1 // именованный блок b1

|

|

|

|

#10 r = 1; // ждать 10 единиц времени

|

|

#20 r = 1; // ждать 20 единиц времени

|

|

#30 r = 1; // ждать 30 единиц времени

|

|

end

|

|

initial begin : b2 // именованный блок b2

|

|

|

|

#5 r = 2; // ждать 5 единиц времени

|

|

#20 r = 2; // ждать 20 единиц времени

|

|

#30 r = 2; // ждать 30 единиц времени

|

|

end

|

|

always @r begin

|

|

|

|

$display ("r = %0d at time %0d", r, $time);

|

|

end

|

|

|

| endmodule

|

`-----------------------------------------------------

'

Рис.2.14 Пример управления временем

1 (в случае posedge) или от

1,

х

или

z

к 0 (в случае negedge). В форме

d) выполнение блока останавливается до тех пор, пока не выполнится событие.

,-------------------------------------------------------.

|

module event_control;

|

|

event e1,e2;

|

|

|

|

initial @e1 begin

|

|

|

|

$display ("I am in the middle.");

|

|

->e2;

|

|

end

|

|

initial @e2

|

|

|

|

$display ("I am supposed to execute last.");

|

|

initial begin

|

|

|

|

$display ("I am the first.");

|

|

->e1;

|

|

end

|

|

endmodule

|

|

|

`-------------------------------------------------------'

Рис.2.15 Пример управления событиями

Событие

может

быть

запущено

выполнением

выражения->cобытие-

переменная.

Следующий

пример

на

рис.2.15

использует

событие-переменные

для

управления

порядком

выполнения

трех

блоков initial,

которые

выполняются

в

один и тот же момент модельного времени.

Выполнение модуля

event_control даст следующие результаты:

I am the first.

Эта

форма

управления

обеспечивает порядок

выполнения.

Без

оператора

управления событиями планировщик языкаVerilog может спланировать

выполнение

блоков initial в

произвольном порядке.

Особой формой конструкции управления временем и событиями является ее ис-

пользование внутри оператора присваивания.

Присваивание current_state = #clock_period next_state;

эквивалентно следующим двум операторам

temp = next_state;

#clock_period current_state = next_state;

и, аналогично, присваивание

current_state = @ (posedge clock) next_state;

эквивалентно двум операторам

temp = next_state;

@ (posedge clock) current_state = temp;

ПОНЯТИЕ ПАРАЛЛЕЛИЗМА

Язык

Verilog

имеет

еще

несколько

управляющих

структур, которые

необычны

для других языков программирования.

Одна из них - конструкция

ветвление-

соединение (fork-join),

другая - оператор блокировки (disable statement).

ПАРА FORK-JOIN

На

рис.2.16

показан

пример

использования конструкции

ветвление-

соединение.

остановлено,

пока не будут

В этом примере выполнение блока initial будет

других,

эти пути

останавливаются

и ждут остальные.

,------------------------------------------.

|

module fork_join;

|

|

event a, b;

|

|

|

|

initial

|

|

|

|

fork

|

|

@a;

|

|

@b;

|

|

join

|

|

end

|

|

endmodule

|

|

|

`------------------------------------------'

Рис.2.16 Пример параллельных процессов

ОПЕРАТОР БЛОКИРОВКИ

Оператор блокировки работает, как оператор

прекращения break языка

Си. Но

в то время как операторbreak в программе

на

языке Си только изменяет про-

граммный

счетчик,

оператор disable

должен

удалить

ждущие

события из

очере-

дей событий. Оператор блокировки берет имя

блока в

качестве

аргумента

и уда-

ляет остальные события, связанные с

этим блоком, из

очереди. Можно блокировать

ция предыдущего, но вместо ожидания выполнения обоих

событий а и b, этот

модуль ждет только одного из них - или а, или b.

,------------------------------------------.

|

module disable_block;

|

|

event a, b;

|

|

// Требуется имя блока

|

|

initial begin : block1

|

|

fork

|

|

@a disable block1;

|

|

@b disable block1;

|

|

join

|

|

end

|

|

endmodule

|

`------------------------------------------'

Рис.2.17 Пример блокировки

ФУНКЦИИ И ЗАДАЧИ

Один из

наиболее

мощных методов моделирования в

языке Verilog - инкапсу-

ляция части

программы

в

виде задачи (task) или функции (function). На рис.2.19

показан пример задачи.

,-------------------------------------------------.

|

function [7:0] func;

|

|

input i1;

|

|

integer i1;

|

|

reg [7:0] rg;

|

|

|

|

begin

|

|

|

|

rg=1;

|

|

for (i=1; i<=i1; i++)

|

|

rg=rg+1;

|

|

func=rg;

|

|

end

|

|

endfunction

|

`-------------------------------------------------'

Рис.2.18 Пример функции

,-----------------------------------------------------.

| task tsk;

|

|

input

i1,i2;

|

|

|

|

output o1,o2;

|

|

|

|

$display ("Task tsk, i1=%0b, i2=%0b", i1,i2); |

|

#1 o1 = i1 & i2;

|

|

#1 o2 = i1 | i2;

|

|

|

| endtask

|

`-----------------------------------------------------'

Рис.2.19 Пример задачи

Есть несколько различий между задачей и функцией.

мо-

Задача

может

содержать конструкции управления временем, а функция не

жет. Это означает,

что функция выполняется за нулевое модельное время

и

вы-

дает результат немедленно (то есть она по существу

комбинационная),

а

задача

может

иметь

задержку

и

программа,

запускающая

задачу,

должна ждать,

пока

не

закончится выполнение задачи или задача не будет блокирована,

прежде, чем про-

должить

выполнение

программы. Управление выполнением

возвращается

к

операто-

ру,

непосредственно следующему

за

оператором,

который

запустил

задачу

или

функцию.

может

иметь

как

входы,

так и выходы,

а

функция

должна

иметь

по

Задача

меньшей

мере

один

вход

и

не

имеет

выходов. Функция

выдает

результат

по

ее

име-

ни.

Вызов

задачи - это

оператор, а

функция

вызывается,

когда

на

нее

ссылаются

в выражении. Например,

tsk (out, in1, in2);

вызывает задачу с именем tsk, а

i = func (a, b, c); // или

assign x = func (y);

вызывает функцию с именем func.

важную

роль

в

логиче-

ском

На рис.2.18 показан пример функции. Функции играют

синтезе.

Так

как функции являются комбинационными, их можно синтезировать

и использовать

в описании

систем.

Задачи - это

очень

важный инструмент

органи-

зации

программы

и

улучшения ее читаемости и простоты

сопровождения.

Часть про-

граммы,

которая

используется более одного

раза,

следует

инкапсулировать

в

задачу. Это помогает

локализовать

любое изменение до этой части программы.

Если ожидается, что

программа будет

выдаваться интерактивно с терминала, ее

также

следует преобразовать в задачу для того, чтобы сэкономить на вводе. Кроме

того,

полезно разбивать длинные процедурные блоки на меньшие зада, чтобыи

Verilog - это язык для проектирования сверху вниз,

который

обеспечивает

функциональное

описание,

структурное описание и

смешанное

описание. В

сле-

дующих

нескольких

разделах мы проиллюстрируем эти аспекты

языка на примере

полного описания 4-разрядного сумматора.

поведение

модуля 4-разрядного сум-

Первый

пример

на

рис.2.20

описывает

матора с использованием конструкций высокого уровня языка Verilog.

Заметим,

что

порты sum и

zero были

объявлены

регистрами. Это сделано,

чтобы функциональный оператор мог присваивать им значение.

В

этом

описании

есть два функциональных элемента, один элемент initial и один элемент always.

Конструкция @(in1

или

in2)

заставляет

моделирование

ждать,

пока

один

из входов in1 или in2 не изменит свое

последнее

значение.

Без

этой

кон-

струкции

цикл always всегда

бы

выполнялся

с

одними

и

теми

же

значениями

входов

и модельное время никогда не продвинется.

запрограммировать как

блок initial,

Заметим,

блок

always

можно

также

используя

управляющую структуру forever, как показано на рис.2.21.

,----------------------------------------------------.

|

module adder4 (in1,in2,sum,zero);

|

|

input [3:0] in1;

|

|

|

|

input [3:0] in2;

|

|

output [4:0] sum;

|

|

output zero;

|

|

reg [4:0] sum;

|

|

reg zero;

|

|

initial begin

|

|

|

|

sum = 0;

|

|

zero = 1;

|

|

end

|

|

always @ (in1 or in2) begin

|

|

|

|

sum = in1 + in2;

|

|

if (sum == 0)

|

|

zero = 1;

|

|

else

|

|

zero = 0;

|

|

end

|

|

endmodule

|

`----------------------------------------------------'

Рис.2.20 Функциональное описание 4-х разрядного сумматора

Следующий

пример

на рис.2.22

является

модификацией

примера

на

рис.2.20,

он моделирует adder4, используя непрерывное присваивание.

Здесь zero является проводом, а не регистром. Когда изменяется sum после

регистра, zero перевычисляется, используя

третичную

операцию "?:" ,

которая

имеет тот же смысл, что и в языке Си, и является выражением,

эквивалентным

оператору если-то-иначе. Объявление

zero

проводом

и

его

непрерывное

присваи-

вание можно записать в один оператор следующим

образом:

wire zero = (sum == 0) ? 1 : 0;

,----------------------------------------------.

|

initial begin

|

|

forever begin

|

|

@ (in1 or in2) begin

|

|

sum = in1 + in2;

|

|

if (sum == 0)

|

|

zero = 1;

|

|

else

|

|

zero = 0;

|

|

end

|

|

end

|

|

end

|

`----------------------------------------------'

Рис.2.21 Использование initial-forever вместо always

,-----------------------------------------------.

|

module adder4 (in1,in2,sum,zero);

|

|

input [3:0] in1;

|

|

input [3:0] in2;

|

|

output [4:0] sum;

|

|

reg [4:0] sum;

|

|

output zero;

|

|

assign zero = (sum == 0) ? 1 : 0;

|

|

|

|

initial sum = 0;

|

|

|

|

always @ (in1 or in2)

|

|

|

|

sum = in1 + in2;

|

|

endmodule

|

`-----------------------------------------------'

Рис.2.22 Использование непрерывного присваивания

СТРУКТУРНОЕ ОПИСАНИЕ

В примере

на

рис.2.23 показана реализация модуля 4-х разрядного сумматора

как структуры,

состоящей из субмодулей 1-разрядного

полного сумматора и

вентилей.

,------------------------------------------------------.

|

module adder4 (in1,in2,sum,zero);

|

|

input [3:0] in1;

|

|

|

|

input [3:0] in2;

|

|

output [4:0] sum;

|

|

output zero;

|

|

fulladd u1 (in1[0],in2[0], 0,sum[0],c0);

|

|

|

|

fulladd u2 (in1[1],in2[1],c0,sum[1],c1);

|

|

fulladd u3 (in1[2],in2[2],c1,sum[2],c2);

|

|

fulladd u4 (in1[3],in2[3],c2,sum[3],sum[4]); |

|

|

|

nor u5 (zero,sum[0],sum[1],sum[2],sum[3],sum[4]); |

|

endmodule

|

|

|

`------------------------------------------------------

'

Рис.2.23 Структурное описание 4-х разрядного сумматора

лей

В

этом

примере 4-х разрядный сумматор

состоит

из

четырех

элементов

моду-

1-разрядного

сумматора (fulladd) и одного элемента модуля вентиля НЕ-ИЛИ.

В этой реализации

описывается

аппаратная

структура

и есть однозначное соот-

ветствие со схемотехникой. Она использует два

типа модулей

более

низкого уров-

ня:

fulladd

и

nor.

Хотя

модуль fulladd

определен

пользователем, а

nor -

это

примитив языка

Verilog,

оба используются одинаковым способом.

с1 и

с2.

Заметим, что

структурное

описание

неявно

объявляет три провода: с0,

Эти

провода

связывают

разряд

переноса

одной ступени

fulladd

со

входом

другой

ступени.

Verilog

разрешает

неявное

объявление

одиночных

разрядов

проводами. Если межсоединение представляет

собой многоразрядную

шину,

требу-

ется явное описание, например:

wire [3:0] databus;

Заметим

также,

что

когда

используется

модуль, важен

порядок

вход-

ных/выходных

портов. Модуль

более

высокого

уровня adder4

требует

установле-

ния связи между его схемой и

соответствующими

портами

модуля

более низкого

уровня fulladd. На рис.2.24 показана простая реализация модуля fulladd.

,------------------------------------------------------.

|

module fulladd (in1,in2,сarryin,sum,carryout);

|

|

input

in1,in2,carryin;

|

|

|

|

output sum,carryout;

|

|

assign {carryout,sum} = in1 + in2 + carryin;

|

|

|

|

endmodule

|

`------------------------------------------------------'

Рис.2.24 Функциональное описание 1-разрядного полного сумматора

СМЕШАННОЕ ПРЕДСТАВЛЕНИЕ

Последний

пример на

рис.2.25

показывает adder4

как комбинацию

структурных

и функциональных элементов.

элементов модулей

Эта

модель

вычисляет

выход sum посредством структурных

fulladd,

а выход zero

вычисляется с использованием функционального элемен-

та.

,------------------------------------------------------.

|

module adder4 (in1,in2,sum,zero);

|

|

input [3:0] in1;

|

|

|

|

input [3:0] in2;

|

|

output [4:0] sum;

|

|

output zero;

|

|

reg zero;

|

|

fulladd u1 (in1[0],in2[0], 0,sum[0],c0);

|

|

|

|

fulladd u2 (in1[1],in2[1],c0,sum[1],c1);

|

|

fulladd u3 (in1[2],in2[2],c1,sum[2],c2);

|

|

fulladd u4 (in1[3],in2[3],c2,sum[3],sum[4]);

|

|

always @ sum

|

|

|

|

if (sum == 0)

|

|

zero = 1;

|

|

else

|

|

zero = 0;

|

|

endmodule

|

|

|

В этой главе мы шаг за

шагом построим функциональную

модель 32-х раз-

рядного

процессора.

Сначала

мы

создадим модель системы команд,

затем опишем

уровень

регистровых

передач.

В

следующей главе мы приступим к описанию струк-

турной

модели,

в которой представим процессор

как совокупность

отдельных бло-

ков. При этом

мы

объясним,

как

моделировать

конвейерную

обработку, паралле-