Características funcionales

Las subrutinas ACC realizan principalmente las siguientes funciones:

  • Leer información relevante de objetos específicos desde la estructura de datos interna
  • Escribir información relevante de objetos específicos en la estructura de datos interna

Los tipos de objetos que pueden manipular las subrutinas ACC son:

  • Instancias de módulos, puertos de módulos, rutas de extremo a extremo de módulos y rutas entre módulos
  • Módulo de nivel superior
  • Instancias de primitivas y puertos de primitivas
  • Tipos de variables como wire, reg, parameter, integer, time, real, etc.
  • Comprobaciones de temporización
  • Eventos nombrados

Las principales características de las subrutinas ACC son:

  • Todas tienen el prefijo acc_
  • Al inicio se debe llamar a acc_initialize() para inicializar el entorno
  • Al salir se debe llamar a acc_close()
  • Al usar funciones de la librería ACC se debe incluir el archivo de cabecera acc_user.h
  • Se accede a los objetos mediante el concepto de manejador (handle). Un manejador es un tipo de datos predefinido que apunta a un objeto específico en el diseño. Una vez obtenido el manejador, se puede acceder a toda la información del objeto. Esto es similar al concepto de manejador de archivos en C. El manejador se declara con la palabra clave handle.

Los principales tipos de subrutinas ACC son:

  • Subrutinas de manejador (handle): devuelven un manejador al objeto en el diseño y siempre tienen el prefijo acc_handle_.
  • Subrutinas de siguiente (next): devuelven un manejador al siguiente objeto en un conjunto específico de objetos del diseño, siempre tienen el prefijo acc_next_ y toman el objeto de referencia como parámetro.
  • Subrutinas de enlace de cambio de valor (VCL, Value Change Link): permiten agregar y eliminar objetos de la lista de objetos que monitorean cambios de valor, siempre tienen el prefijo acc_vcl_ y no devuelven valor.
  • Subrutinas de obtención (fetch): pueden extraer información de atributos como la ruta jerárquica, siempre tienen el prefijo acc_fetch_.
  • Subrutinas diversas (miscellaneous): se utilizan para realizar operaciones varias relacionadas con las subrutinas de acceso, por ejemplo acc_initialize() y acc_close() pertenecen a este tipo.
  • Subrutinas de modificación (modify): pueden modificar la estructura de datos interna.

Para la lista completa de subrutinas ACC y una breve explicación de su uso, consulte la siguiente sección.«8.5 Lista de subrutinas ACC»。

Ejemplos de subrutinas ACC

A continuación se muestran ejemplos de uso de algunas subrutinas ACC, principalmente para ilustrar el flujo básico de diseño de tareas de sistema Verilog utilizando subrutinas ACC.

Requisitos de diseño

En esta ocasión se diseña una tarea de sistema para monitorear un contador.

Por un lado, esta tarea de sistema monitorea el valor del contador en Verilog; por otro lado, tras detectar el reloj de conteo en Verilog, también realiza un conteo por software y compara los valores de conteo de software y hardware para verificar la corrección de la lógica de hardware. Además, cuando el contador alcanza un valor específico, se emiten los valores de algunas variables de señal.

Este enfoque de diseño es también un escenario de uso frecuente de la interfaz PLI. El software implementa una función lógica, denominada CModel. Luego, el hardware también implementa la misma función lógica usando Verilog. Mediante el programa de interfaz PLI, los programas de software y hardware pueden ejecutarse simultáneamente y comparar resultados para verificar la corrección del diseño lógico de hardware.

Análisis de diseño

La parte de interfaz PLI utiliza subrutinas de enlace de cambio de valor (VCL) para monitorear el reloj. En cuanto llega el flanco de subida del reloj, se llama a la función de software para realizar el conteo por software y comparar los valores de conteo de software y hardware.

Diseño de software

El código de diseño de software es el siguiente; los detalles se explican en los comentarios. Se guarda en el archivo monitor_gyc.c.

Ejemplo

#include "acc_user.h"

handle  hand_rstn, hand_clk, hand_cnt, hand_cout ;
int cnt_soft  = 0 ;   // Valor del contador de software
int cout_soft = 0 ;   // Bit de desbordamiento del contador de software

// Función de conteo y comparación por software
void act_monitor(){
    p_acc_value value ; // Declarar variables de estructura definidas en ACC
    // Leer el valor de una variable de señal en Verilog, tipo cadena
    char *rstn_rtl_str = acc_fetch_value(hand_rstn, "%d", value);
    char *clk_rtl_str  = acc_fetch_value(hand_clk, "%d", value);
    char *cnt_rtl_str  = acc_fetch_value(hand_cnt, "%d", value);
    char *cout_rtl_str = acc_fetch_value(hand_cout, "%d", value);

    // Convertir cadena a entero
    int rstn_rtl       = atoi(rstn_rtl_str) ;
    int clk_rtl        = atoi(clk_rtl_str) ;
    int cnt_rtl        = atoi(cnt_rtl_str) ;
    int cout_rtl       = atoi(cout_rtl_str) ;

    // Contador de software
    // Reinicio
    if (!rstn_rtl) {
        cnt_soft    = 0 ;
        cout_soft   = 0 ;
        io_printf("---iii--- Reset state! \n");
    }
    // Funcionamiento normal
    else if (rstn_rtl && clk_rtl) {
        if (cnt_soft == 9) {
            cnt_soft    = 0 ;    // Contar 10
        }
        else {
            cnt_soft    = cnt_soft + 1 ; // Contar
        }
    }
    cout_soft = cnt_soft == 9 ? 1 : 0 ; // Acarreo

    // Comparar el conteo de software y hardware cuando el reloj está en bajo; este es un momento relativamente seguro
    if (!clk_rtl && rstn_rtl) {
        if ((cnt_soft != cnt_rtl) || (cout_soft != cout_rtl)) {
            io_printf("--Err--- rtl cnt: %d, and soft cnt: %d\n", cnt_rtl, cnt_soft);
            io_printf("--Err--- rtl cout: %d, and soft cout: %d\n", cout_rtl, cout_soft);
        }
        // Si no hay error en la comparación entre el conteo de software y hardware, se genera una vez el valor de estado de la señal al finalizar el conteo
        else if (cnt_soft == 9)  {
            io_printf("--Monitor--- rtl and soft cnt: %d\n", cnt_soft);
            io_printf("--Monitor--- rtl and soft cout: %d\n", cout_soft);
        }
    }
}

// Interfaz PLI, monitorear cambios del reloj
void my_monitor() {
    acc_initialize(); // Debe inicializarse
    // Obtener la variable handle del primer parámetro de la tarea de sistema my_monitor
    hand_rstn   = acc_handle_tfarg(1);
    hand_clk    = acc_handle_tfarg(2);
    hand_cnt    = acc_handle_tfarg(3);
    hand_cout   = acc_handle_tfarg(4);
    //"#define VCL_VERILOG_LOGIC 2" in acc_user.h
    //Indicates the VCL callback mechanism shall report
    // Tan pronto como hand_clk cambie, se llama a la función act_monitor
    acc_vcl_add(hand_clk, act_monitor, null, vcl_verilog_logic);
    acc_close(); // Cerrar la tarea
}

Diseño de hardware

La descripción Verilog del contador decimal (base 10) es la siguiente; se guarda en el archivo counter10.v.

Ejemplo

module counter10(
   input                rstn,
   input                clk,
   output [3:0]         cnt,
   output               cout);

   reg [3:0]            cnt_temp ;
   always@(posedge clk or negedge rstn) begin
      if (! rstn) begin
         cnt_temp        <= 4'b0 ;
      end
      else if (cnt_temp==4'd9) begin
         cnt_temp        <=4'b000;
      end
      else begin
         cnt_temp        <= cnt_temp + 1'b1 ;
      end
   end

   assign  cout = (cnt_temp==4'd9) ;
   assign  cnt  = cnt_temp ;

endmodule

testbench

La descripción del testbench es la siguiente; se guarda en el archivo test.v.

Ejemplo

`timescale 1ns/1ps
module test ;
   reg          rstn, clk ;
   wire [3:0]   cnt ;
   wire         cout ;

   initial begin
      rstn      = 0 ;
      clk       = 0 ;
      #19.8;
      rstn      = 1 ;
   end
   always #5 clk = ~clk ;

   counter10 u_cnt(
     .rstn      (rstn),
     .clk       (clk),
     .cnt       (cnt),
     .cout      (cout));

   initial begin
      $my_monitor(test.rstn, test.clk, test.cnt, test.cout);
   end

   initial begin
      forever begin
         #100;
         if ($time >= 300)  $finish ;
      end
   end
endmodule

Compilación y simulación

En Linux, use el siguiente comando para compilar monitor_gyc.c y generar el archivo monitor_gyc.o; preste atención a la ruta relativa.

gcc -I ${VCS_HOME}/include -c ../tb/monitor_gyc.c

Para compilar con VCS, es necesario crear un archivo de enlace reconocible por VCS, con el nombre pli_gyc.tab, cuyo contenido es el siguiente.

$my_monitor es el nombre de la tarea de sistema invocada por Verilog;

call=my_monitor indica que se llama a la función my_monitor() del programa C de software;

acc=rw:* indica las propiedades de la tarea de sistema; rw significa que se pueden leer y escribir datos internos; después de los dos puntos se puede declarar el módulo o área de señal sobre la que actúa la tarea de sistema; ":*" significa que puede actuar sobre todos los módulos.

$my_monitor call=my_monitor acc=rw:*

Al compilar con VCS, añada la siguiente línea de parámetros.

-P ../tb/pli_gyc.tab

El log del resultado de la simulación es el siguiente.

Según el log, la comparación del conteo entre software y hardware es correcta, y el estado del contador al completar un ciclo de conteo también es normal.

Descarga del código fuente de este capítulo

Download