Ключевые слова: 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 с задержкой описывается следующим образом:

Пример

task xor_oper_iner;
    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

При объявлении задачи можно также добавить круглые скобки после имени задачи, чтобы заключить в них объявления портов.

Приведённый выше проект можно изменить на:

Пример

task xor_oper_iner(
    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.

Пример

module xor_oper
    #(параметр         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; тестовый стенд описан следующим образом.

Для части со стимулами мы используем простую задачу для её описания, что делает стимулы более ясными и краткими.

На самом деле, наиболее распространённый сценарий применения задач — в тестовых стендах для симуляции. Задачи также не поддерживаются для синтеза в некоторых компиляторах.

Пример

`timescale 1ns/1ns
 
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, определённых внутри задачи.

Задача, работающая с глобальными переменными

Поскольку задачу можно рассматривать как процедурное присваивание, время возврата сигналов выходного порта наступает после выполнения всех операторов в задаче.

Переменные внутри задачи видны только внутри задачи. Если вы хотите специально наблюдать процесс работы с переменными в задаче, нужно объявить наблюдаемые переменные внутри модуля, но вне задачи; их можно назвать "глобальными переменными".

Например, есть следующие два описания, которые пытаются использовать задачу для генерации тактового сигнала.

Пример

//способ1 описать генерацию clk, не работает
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, и задача вызывается дважды, может возникнуть интерференция сигналов, например, как описано в следующем коде:

Пример

task test_flag ;
        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;

Видно, что при двух параллельных вызовах, поскольку пространства хранения независимы друг от друга, сигналы не влияют друг на друга.

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

Скачать