Palabras clave: tarea

Diferencias entre tareas y funciones

Al igual que las funciones, las tareas (task) se pueden usar para describir segmentos de código comunes y se pueden invocar en cualquier lugar dentro del módulo, haciendo que el código sea más intuitivo y legible. Las funciones generalmente se usan para varias conversiones y cálculos de lógica combinacional, mientras que las tareas son más como un procedimiento; no solo pueden completar la funcionalidad de las funciones, sino que también pueden incluir lógica de control temporal. A continuación se resumen las diferencias entre tareas y funciones:

Punto de comparaciónFunciónTarea
EntradaUna función tiene al menos una entrada; la declaración de puertos no puede incluir el tipo inoutUna tarea puede no tener o tener múltiples entradas, y la declaración de puertos puede ser de tipo inout
SalidaUna función no tiene salidasUna tarea puede no tener o tener múltiples salidas
Valor de retornoUna función tiene al menos un valor de retornoUna tarea no tiene valor de retorno
Momento de simulaciónUna función siempre comienza a ejecutarse en el tiempo ceroUna tarea puede ejecutarse en un tiempo distinto de cero
Lógica secuencialUna función no puede contener ninguna lógica de control secuencialUna tarea no puede contener sentencias always, pero puede incluir otros controles de temporización, como sentencias de retardo
LlamadaUna función solo puede llamar a funciones, no puede llamar a tareasUna tarea puede llamar a funciones y a tareas
Regla de escrituraUna función no puede aparecer como una sentencia independiente; solo puede colocarse en el lado derecho de una sentencia de asignaciónUna tarea puede aparecer como una sentencia independiente dentro de un bloque de sentencias

Tarea

Declaración de tarea

Una tarea se define en cualquier lugar del módulo y se puede referenciar en cualquier lugar dentro del módulo; su ámbito también se limita a este módulo.

Cuando un subprograma dentro del módulo cumpla cualquiera de las siguientes condiciones, se debe usar una tarea en lugar de una función.

  • 1) El subprograma contiene lógica de control de temporización, por ejemplo retardos, control de eventos, etc.
  • 2) No tiene variables de entrada
  • 3) No tiene salidas o el número de salidas es mayor que 1

El formato de declaración de una tarea en Verilog es el siguiente:

task       task_id ;
    port_declaration ;
    procedural_statement ;
endtask

En una tarea, se utilizan las palabras clave input, output e inout para declarar los puertos. Los puertos de tipo input e inout pasan variables desde el exterior de la tarea al interior; los puertos de tipo output e inout devuelven al exterior los resultados cuando la tarea ha terminado de ejecutarse.

Al diseñar la lógica de la tarea, las variables de puerto declaradas como input pueden considerarse de tipo wire, y las variables de puerto declaradas como output pueden considerarse de tipo reg. Sin embargo, no es necesario volver a declarar los puertos de salida con reg.

Tampoco se debe usar la palabra clave assign al asignar señales de salida. Para evitar problemas de temporización, se recomienda usar asignación bloqueante para las señales de salida.

Por ejemplo, una tarea con función XOR con retardo se describe de la siguiente manera:

Ejemplo

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 ; //no es necesario volver a indicar el tipo reg, aunque indicarlo tampoco sería incorrecto
    #3  numco = numa ^ numb ;
    //assign #3 numco = numa ^ numb ; //no usar assign, porque la salida es reg por defecto
endtask

Al declarar una tarea, también se puede agregar un paréntesis después del nombre de la tarea para encerrar la declaración de puertos.

El diseño anterior se puede cambiar a:

Ejemplo

task xor_oper_iner(
    input [N-1:0]   numa,
    input [N-1:0]   numb,
    output [N-1:0]  numco  ) ;
    #3  numco       = numa ^ numb ;
endtask

Llamada de tarea

Una tarea puede aparecer como una sentencia independiente en un bloque initial o always; el formato de llamada es el siguiente:

task_id(input1, input2, …,outpu1, output2, …);

Al llamar a una tarea, los puertos deben corresponder en orden.

Las señales dentro del módulo conectadas a los puertos de entrada pueden ser de tipo wire o reg. Las señales dentro del módulo conectadas a los puertos de salida deben ser de tipo reg; esto es algo a tener en cuenta.

Realice una llamada a la tarea XOR anterior para almacenar en búfer el resultado XOR.

Ejemplo

module xor_oper
    #(parameter         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          //llamada de tarea
        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 ;         //almacenamiento en búfer de datos
        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 ;   //asignación bloqueante, fácil de controlar la temporización
    endtask
 
endmodule

Para simular de forma sencilla el diseño XOR anterior, el testbench se describe a continuación.

Para la parte de estímulos usamos una tarea simple para describirla, lo que hace que los estímulos se vean más claros y concisos.

En realidad, el escenario de aplicación más común de las tareas es usarlas en testbenchs para simulación. Las tareas tampoco son compatibles con la síntesis en algunos compiladores.

Ejemplo

`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

El resultado de la simulación es el siguiente.

Como se muestra en la figura, el resultado lógico de la salida XOR es correcto, con un retardo de 3ns con respecto a la entrada.

Además, las señales conectadas a, b, co_t mantienen el mismo estado que las señales internas de la tarea numa, numb, numco.

Tareas que operan sobre variables globales

Debido a que una tarea puede considerarse como una asignación procedural, el tiempo en que la señal del puerto de salida de la tarea se devuelve es después de que se hayan ejecutado todas las sentencias de la tarea.

Las variables internas de una tarea solo son visibles dentro de la tarea. Si se desea observar en detalle el proceso de operación sobre las variables dentro de la tarea, es necesario declarar las variables a observar dentro del módulo y fuera de la tarea; se les puede llamar "variables globales".

Por ejemplo, existen las siguientes dos formas de intentar generar un reloj usando una tarea.

Ejemplo

//way1 to decirbe clk generating, not work
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: use task to operate global varialbes to generating clk
reg          clk_test2 ;
task clk_rvs_global ;
        # 5 ;     clk_test2 = 0 ;
        # 5 ;     clk_test2 = 1 ;
endtask // clk_rvs_iner
always clk_rvs_global;

El resultado de la simulación es el siguiente.

En la primera forma de descripción, aunque las variables internas de la tarea tienen operaciones de asignación de 0 y asignación de 1, el proceso de cambio intermedio no es visible; el resultado final solo puede ser el valor final de la señal de salida después de que se ejecuten todas las sentencias dentro de la tarea. Por lo tanto, la señal clk_test1 es constantemente 1, y esta forma no puede generar un reloj.

En la segunda forma de descripción, aunque no hay señales de puerto, se realizan operaciones procedurales directamente sobre la "variable global"; como esta variable global es visible para el módulo, el proceso de conmutación de la señal dentro de la tarea se reflejará en la señal clk_test2.

Tareas automáticas

Al igual que las funciones, en Verilog las variables locales de una tarea son estáticas cuando se invoca. Se puede usar la palabra clave automatic para declarar la tarea; de esta manera, los espacios de almacenamiento se pueden asignar dinámicamente en cada invocación, y cada tarea invocada opera de forma independiente sobre su propio espacio de direcciones exclusivo, sin afectar la ejecución concurrente de múltiples invocaciones de la misma tarea.

Si un segmento de código de una tarea se invoca en 2 o más lugares, debe declararse con la palabra clave automatic.

Cuando una tarea no se declara con automatic, y la tarea se invoca 2 veces, puede ocurrir interferencia entre señales, como se describe en el siguiente código:

Ejemplo

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)

El resultado de la simulación es el siguiente.

Cuando en_cnt está en alto, la señal en en la tarea (1) está activa, y cnt1 puede generar el valor lógico correcto;

En este momento, la señal en en la tarea (2) no está habilitada, por lo que el valor de cnt2 es sobrescrito por la variable compartida cnt_temp impulsada por la tarea (1).

Cuando en_cnt está en bajo, la señal en en la tarea (2) está activa, por lo que la señal cnt2 en la tarea (2) puede generar el valor lógico correcto; mientras tanto, el valor de la señal cnt1 es sobrescrito una y otra vez, impulsado por el reloj, por la variable compartida cnt_temp impulsada por la tarea (2).

Se puede ver que, en dos invocaciones concurrentes, la tarea comparte espacio de almacenamiento, lo que hace que las señales se afecten entre sí.

Las demás descripciones permanecen igual; solo se agrega la palabra clave automatic en la declaración de la tarea anterior, como se muestra a continuación.

task automatic test_flag ;

El resultado de la simulación en este caso es el siguiente.

  • Cuando en_cnt está en alto, la señal cnt1 en la tarea (1) puede generar el valor lógico correcto, y el valor de la señal cnt2 en la tarea (2) es X;
  • Cuando en_cnt está en bajo, la señal cnt2 en la tarea (2) puede generar el valor lógico correcto, y el valor de la señal cnt1 en la tarea (1) es X;

Se puede ver que, en dos invocaciones concurrentes, debido a que los espacios de almacenamiento son independientes entre sí, no hay influencia entre las señales.

Descarga del código fuente

Download