Ключевые слова: Task
Различия между задачами и функциями
Как и функции, задачи могут использоваться для описания общих сегментов кода и могут вызываться в любом месте внутри модуля, что делает код более интуитивно понятным и читаемым. Функции обычно используются для различных преобразований и вычислений в комбинационной логике, тогда как задачи больше похожи на процедуры. Они могут не только реализовывать функциональность функций, но и включать логику управления временем. Различия между задачами и функциями обобщены ниже:
| Пункт сравнения | Функция | Задача |
|---|---|---|
| Ввод | Функция должна иметь как минимум один вход, и объявление порта не может содержать тип inout | Задача может не иметь входов или иметь несколько входов, и объявление порта может быть типа inout |
| Вывод | Функция не имеет выхода | Задача может не иметь выходов или иметь несколько выходов |
| Возвращаемое значение | Функция имеет по крайней мере одно возвращаемое значение | Задача не имеет возвращаемого значения |
| Время моделирования | Функция всегда начинает выполняться в момент времени ноль | Задача может выполняться в моменты времени, отличные от нуля |
| Последовательностная логика | Функция не может содержать никакой логики управления временем | Задача не может содержать операторы always, но может включать другие средства управления временем, такие как операторы задержки |
| Вызов | Функция может вызывать только функции, но не задачи | Задача может вызывать функции и задачи |
| Стандарты кодирования | Функция не может использоваться как отдельный оператор; она может быть помещена только в правую часть оператора присваивания | Задача может использоваться как отдельный оператор в блоке операторов |
Задача
Объявление задачи
Задача определяется в любом месте модуля и вызывается из любого места внутри модуля; ее область видимости также ограничена этим модулем.
Когда подпрограмма в модуле удовлетворяет любому из следующих условий, необходимо использовать задачу вместо функции.
- 1) Подпрограмма содержит логику управления временем, например задержки, управление событиями и т. д.
- 2) Отсутствуют входные переменные
- 3) Отсутствует выход или количество выходов больше 1
Формат объявления задачи в Verilog следующий:
task task_id ; port_declaration ; procedural_statement ; endtask
В задаче ключевые слова input, output и inout используются для объявления портов. Порты типа input и inout передают переменные извне задачи внутрь, а порты типа output и inout возвращают результаты наружу по завершении выполнения задачи.
При выполнении логического проектирования задачи переменные портов, объявленные как input, можно рассматривать как тип wire, а переменные портов, объявленные как output, можно рассматривать как тип reg. Однако нет необходимости повторно объявлять выходные порты как reg.
При присваивании значений выходным сигналам не используйте ключевое слово assign. Чтобы избежать путаницы с временем, для выходных сигналов рекомендуется использовать блокирующее присваивание.
Например, задача с функцией XOR с задержкой описывается следующим образом:
Пример
input [N-1:0] numa;
input [N-1:0] numb;
output [N-1:0] numco ;
//output reg [N-1:0] numco ; //Нет необходимости снова указывать тип reg, хотя указать его тоже не будет ошибкой
#3 numco = numa ^ numb ;
//assign #3 numco = numa ^ numb ; //Не используйте assign, потому что выход по умолчанию имеет тип reg
endtask
При объявлении задачи можно также добавить круглые скобки после имени задачи, чтобы заключить в них объявления портов.
Приведённый выше проект можно изменить на:
Пример
input [N-1:0] numa,
input [N-1:0] numb,
output [N-1:0] numco ) ;
#3 numco = numa ^ numb ;
endtask
Вызов задачи
Задача может выступать в качестве отдельного оператора в блоке initial или always, а формат вызова следующий:
task_id(input1, input2, …,outpu1, output2, …);
При вызове задачи порты должны соответствовать по порядку.
Сигналы в модуле, подключённые к входным портам, могут быть типа wire или reg. Сигналы в модуле, подключённые к выходным портам, должны быть типа reg; на это нужно обратить внимание.
Вызовите вышеуказанную задачу функции XOR, чтобы завершить буферизацию результата XOR.
Пример
#(параметр N = 4)
(
input clk ,
input rstn ,
input [N-1:0] a ,
input [N-1:0] b ,
output [N-1:0] co );
reg [N-1:0] co_t ;
always @(*) begin //Вызов задачи
xor_oper_iner(a, b, co_t);
end
reg [N-1:0] co_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
co_r <= 'b0 ;
end
else begin
co_r <= co_t ; //Буферизация данных
end
end
assign co = co_r ;
/*------------ task -------*/
task xor_oper_iner;
input [N-1:0] numa;
input [N-1:0] numb;
output [N-1:0] numco ;
#3 numco = numa ^ numb ; //Блокирующее присваивание, легко управлять временем
endtask
endmodule
Выполните простую симуляцию приведённого выше проекта функции XOR; тестовый стенд описан следующим образом.
Для части со стимулами мы используем простую задачу для её описания, что делает стимулы более ясными и краткими.
На самом деле, наиболее распространённый сценарий применения задач — в тестовых стендах для симуляции. Задачи также не поддерживаются для синтеза в некоторых компиляторах.
Пример
module test ;
reg clk, rstn ;
initial begin
rstn = 0 ;
#8 rstn = 1 ;
forever begin
clk = 0 ; # 5;
clk = 1 ; # 5;
end
end
reg [3:0] a, b;
wire [3:0] co ;
initial begin
a = 0 ;
b = 0 ;
sig_input(4'b1111, 4'b1001, a, b);
sig_input(4'b0110, 4'b1001, a, b);
sig_input(4'b1000, 4'b1001, a, b);
end
task sig_input ;
input [3:0] a ;
input [3:0] b ;
output [3:0] ao ;
output [3:0] bo ;
@(posedge clk) ;
ao = a ;
bo = b ;
endtask ; // sig_input
xor_oper u_xor_oper
(
.clk (clk ),
.rstn (rstn ),
.a (a ),
.b (b ),
.co (co ));
initial begin
forever begin
#100;
if ($time >= 1000) $finish ;
end
end
endmodule // test
Результаты моделирования следующие.
Из рисунка видно, что результат логики выхода XOR правильный, с задержкой 3ns относительно входа.
Кроме того, подключённые сигналы a, b, co_t остаются согласованными с состояниями сигналов numa, numb, numco, определённых внутри задачи.

Задача, работающая с глобальными переменными
Поскольку задачу можно рассматривать как процедурное присваивание, время возврата сигналов выходного порта наступает после выполнения всех операторов в задаче.
Переменные внутри задачи видны только внутри задачи. Если вы хотите специально наблюдать процесс работы с переменными в задаче, нужно объявить наблюдаемые переменные внутри модуля, но вне задачи; их можно назвать "глобальными переменными".
Например, есть следующие два описания, которые пытаются использовать задачу для генерации тактового сигнала.
Пример
task clk_rvs_iner ;
output clk_no_rvs ;
# 5 ; clk_no_rvs = 0 ;
# 5 ; clk_no_rvs = 1 ;
endtask
reg clk_test1 ;
always clk_rvs_iner(clk_test1);
//way2: использовать task для работы с глобальными переменными для генерации clk
reg clk_test2 ;
task clk_rvs_global ;
# 5 ; clk_test2 = 0 ;
# 5 ; clk_test2 = 1 ;
endtask // clk_rvs_iner
always clk_rvs_global;
Результаты моделирования следующие.
В первом описании, хотя внутренние переменные задачи имеют процедурные операции присваивания 0 и присваивания 1, промежуточный процесс изменения не виден. Результат на выходе может быть только конечным значением сигнала выходного порта после выполнения всех операторов задачи. Поэтому сигнал clk_test1 всегда равен 1, и этот метод не может генерировать тактовый сигнал.
Во втором описании, хотя портовых сигналов нет, задача напрямую выполняет процедурные операции с «глобальной переменной». Поскольку глобальная переменная видна модулю, процесс переключения сигнала внутри задачи будет отражён в сигнале clk_test2.
Автоматическая задача
Как и функции, локальные переменные при вызове задачи в Verilog являются статическими. Ключевое слово automatic можно использовать для объявления задачи, чтобы при вызове задачи каждая область памяти могла выделяться динамически. Каждая вызванная задача независимо работает в своём уникальном адресном пространстве, не влияя на параллельное выполнение нескольких вызовов одной и той же задачи.
Если сегмент кода задачи вызывается в двух или более местах, он должен быть объявлен с ключевым словом automatic.
Когда задача не объявлена как automatic, и задача вызывается дважды, может возникнуть интерференция сигналов, например, как описано в следующем коде:
Пример
input [3:0] cnti ;
input en ;
output [3:0] cnto ;
if (en) cnto = cnti ;
endtask
reg en_cnt ;
reg [3:0] cnt_temp ;
initial begin
en_cnt = 1 ;
cnt_temp = 0 ;
#25 ; en_cnt = 0 ;
end
always #10 cnt_temp = cnt_temp + 1 ;
reg [3:0] cnt1, cnt2 ;
always @(posedge clk) test_flag(2, en_cnt, cnt1); //task(1)
always @(posedge clk) test_flag(cnt_temp, !en_cnt, cnt2);//task(2)
Результаты моделирования следующие.
Когда en_cnt находится на высоком уровне, сигнал en в задаче (1) активен, и cnt1 может выдавать корректное логическое значение;
В это время сигнал en в задаче (2) не включен, поэтому значение cnt2 перезаписывается разделяемой переменной cnt_temp, управляемой задачей (1).
Когда en_cnt находится на низком уровне, сигнал en в задаче (2) активен, поэтому сигнал cnt2 в задаче (2) может выдавать корректное логическое значение; в это время под управлением тактового сигнала значение сигнала cnt1 многократно перезаписывается разделяемой переменной cnt_temp, управляемой задачей (2).
Видно, что при двух параллельных вызовах задача использует общее пространство хранения, из-за чего сигналы влияют друг на друга.
Остальные описания остаются без изменений; в приведенное выше объявление задачи добавлено только ключевое слово automatic, как показано ниже.
task automatic test_flag ;
Результаты моделирования в этом случае выглядят следующим образом.
- Когда en_cnt находится на высоком уровне, сигнал cnt1 в задаче (1) может выдавать корректное логическое значение, а значение сигнала cnt2 в задаче (2) равно X;
- Когда en_cnt находится на низком уровне, сигнал cnt2 в задаче (2) может выдавать корректное логическое значение, а значение сигнала cnt1 в задаче (1) равно X;
Видно, что при двух параллельных вызовах, поскольку пространства хранения независимы друг от друга, сигналы не влияют друг на друга.

Скачать исходный код
Скачать