Simular RTL guardado y conservar el resultado

Guarde una solicitud de simulación RTL acotada, pásela por admit y preflight, ejecútela y, después, almacene, enumere y vuelva a abrir el resultado en su proyecto.

Utilice Altifigence CLI 0.1.9 en Linux para simular SystemVerilog guardado con el motor RTL incluido. Los comandos de simulación admit, preflight y run leen, cada uno, un archivo de solicitud dentro de su proyecto y muestran JSON. Para leer el contrato de simulación de cuatro estados con varios relojes, ejecute alti rtl simulate-v2 capabilities.

Guardar una solicitud de simulación

Cree la carpeta del proyecto y guarde en ella esta solicitud como sim.json. Utilice exactamente estas cuatro claves de nivel superior. La solicitud contiene el código fuente SystemVerilog, el puerto y el período del reloj, un reset opcional, los valores iniciales de los registros y un vector de entrada por ciclo.

mkdir -p "$HOME/alti-projects/demo-project"
PROJECT="$(cd "$HOME/alti-projects/demo-project" && pwd -P)"

{
  "schema": "altifigence.rtl.operation-request.v1",
  "version": 1,
  "operationId": "altifigence.rtl.simulate.v1",
  "request": {
    "top": "top",
    "sources": [
      {
        "path": "workspace/top.sv",
        "source": "module top(\n  input logic clk,\n  input logic rst,\n  input logic d,\n  output logic q\n);\n  always_ff @(posedge clk or posedge rst)\n    if (rst) q <= 1'b0;\n    else q <= d;\nendmodule\n"
      }
    ],
    "clock": {
      "port": "clk",
      "periodPs": 1000
    },
    "initialRegisterValues": [
      false
    ],
    "cycles": [
      {
        "inputs": {
          "d": [
            false
          ]
        }
      },
      {
        "inputs": {
          "d": [
            true
          ]
        }
      },
      {
        "inputs": {
          "d": [
            true
          ]
        }
      },
      {
        "inputs": {
          "d": [
            false
          ]
        }
      }
    ],
    "limits": {
      "maxCycles": 4,
      "maxTimePs": 4000
    },
    "reset": {
      "port": "rst",
      "activeLevel": "active_high",
      "assertCycles": 1
    }
  }
}

Indique en cada ciclo todas las entradas de nivel superior, excepto el reloj y el reset, con el bit menos significativo primero. El motor genera el reloj y activa el reset durante los primeros assertCycles ciclos. Mantenga clock.periodPs de 2 a 1000000000. Establezca limits.maxCycles desde el número de ciclos hasta 32768, y limits.maxTimePs desde ciclos × periodPs hasta 1000000000000. El archivo de solicitud puede tener hasta 272629760 bytes.

Comprobar la solicitud antes de ejecutarla

alti rtl simulate admit --project "$PROJECT" sim.json
alti rtl simulate preflight --project "$PROJECT" sim.json > "$PROJECT/preflight.json"
jq -c '[.outputPorts[].name]' "$PROJECT/preflight.json"

Compruebe que el estado de salida de cada comando sea 0. Admit comprueba la estructura y los límites de la solicitud y devuelve altifigence.rtl.simulation-admission.v1 con admitted en true; para esta solicitud indica cycleCount 4, transitionStepCount 8 y simulatedTimePs 4000. Preflight también sintetiza el código fuente en una netlist lógica y devuelve altifigence.rtl.simulation-preflight.v1 con los puertos de entrada, los puertos de salida y los registros. La línea de jq imprime:

["q"]

Admit y preflight son comprobaciones previas. La simulación se ejecuta solo con run.

Ejecutar la simulación

alti rtl simulate run --project "$PROJECT" sim.json > "$PROJECT/result.json"
jq -c '.artifact.payload.summaryArtifact.payload.finalOutputsLsb0' "$PROJECT/result.json"
jq -r '.artifact.payload.waveformArtifact.payload' "$PROJECT/result.json" > "$PROJECT/wave.vcd"

Compruebe que el estado de salida sea 0. El resultado tiene el esquema altifigence.rtl.operation-result.v1 y operationId altifigence.rtl.simulate.v1. Su artefacto es un comprobante altifigence.rtl.simulation-receipt.v1 con el preflight, una traza de pasos de eventos, una forma de onda VCD, un resumen y la procedencia. Para esta solicitud, la salida final es:

{"q":[false]}

El motor incluido sintetiza el diseño y lo ejecuta con su propio simulador de pasos de eventos de dos estados. wave.vcd usa una escala de tiempo de 1ps.

Inspeccionar y sintetizar el código fuente

Guarde el mismo módulo como archivo del proyecto y, después, genere su esquemático y sintetícelo. Las rutas de los archivos de código fuente son relativas al proyecto.

mkdir -p "$PROJECT/rtl"
jq -r '.request.sources[0].source' "$PROJECT/sim.json" > "$PROJECT/rtl/top.sv"
alti rtl schematic --project "$PROJECT" --top top rtl/top.sv > "$PROJECT/schematic.json"
jq -c '{schema, source}' "$PROJECT/schematic.json"

Compruebe que el estado de salida sea 0. La línea de jq imprime:

{"schema":"alti-rtl-schematic.v1","source":"saved-files"}

El documento también contiene topModule, modules, instances, nets, connections, diagnostics y unsupported. Su status es complete o partial; un documento failed termina con el estado de salida 1.

alti rtl synth --project "$PROJECT" --top top rtl/top.sv > "$PROJECT/synth.json"
jq -c '{report: .report.schema, netlist: .netlist.schema, cells: .report.stats.cells_by_kind}' "$PROJECT/synth.json"

Compruebe que el estado de salida sea 0. Synth imprime la netlist lógica y su informe de síntesis. Para este módulo, la línea de jq imprime:

{"report":"rtl-synth-report-2","netlist":"logic-netlist-2","cells":{"dff_posedge_async_reset":1}}

Si synth se detiene con alti-rtl: synth requires at least one SystemVerilog file, añada la ruta del archivo de código fuente, como rtl/top.sv, después de las opciones.

Conservar y volver a abrir el resultado

alti rtl artifact store --project "$PROJECT" result.json > "$PROJECT/manifest.json"
ENTRY_ID="$(jq -r '.entryId' "$PROJECT/manifest.json")"
alti rtl artifact list --project "$PROJECT"
alti rtl artifact show --project "$PROJECT" "$ENTRY_ID" > "$PROJECT/reopened.json"

Store valida el resultado completo y lo escribe bajo .altifigence/artifacts/rtl/ en el proyecto. Su manifiesto altifigence.rtl.artifact-manifest.v1 contiene entryId, el SHA-256 del resultado almacenado y relativePath results/<entryId>.json. List imprime todos los manifiestos; show imprime el JSON del resultado almacenado. Un resultado puede tener hasta 67108864 bytes.

Resolver errores

Si aparece RTL simulation request must be the exact altifigence.rtl.simulate.v1 envelope, incluya en el archivo exactamente las claves schema, version, operationId y request con los valores mostrados arriba.

Si aparece RTL simulation request must be a normalized project-relative path, pase la ruta relativa al proyecto, como sim.json, sin ./ ni / al principio.

El motor imprime los errores de la solicitud después de alti-rtl: y termina con el estado de salida 2. Si aparece RTL simulation resource limit exceeded for stimulus cycles: observed 5, maximum 4, aumente limits.maxCycles hasta el número de ciclos y ejecute admit de nuevo.

Si aparece RTL simulation resource limit exceeded for simulated time ps: observed 5000, maximum 4000, aumente limits.maxTimePs hasta al menos el número de ciclos × clock.periodPs.

Si aparece RTL artifact entry does not exist: seguido de un ID, copie un entryId de alti rtl artifact list y ejecute show de nuevo.

Comprobar y analizar fuentes guardadas

Utilice el archivo rtl/top.sv guardado de la sección anterior. Compruebe sus diagnósticos, examine la cobertura del comprobador y la jerarquía, y lea después el análisis nativo de símbolos. Coloque las opciones de ejecución después del subcomando del compilador.

alti rtl compile check --runner local --project "$PROJECT" -- rtl/top.sv --format json
alti rtl compile coverage --runner local --project "$PROJECT" -- rtl/top.sv --format json
alti rtl compile hierarchy --runner local --project "$PROJECT" -- rtl/top.sv --top top --format json
alti rtl analysis --project "$PROJECT" rtl/top.sv > "$PROJECT/analysis.json"
jq -c '{schemaVersion}' "$PROJECT/analysis.json"

{"schemaVersion":"sv-symbols.v2"}

La forma compatible synthesize también ejecuta el sintetizador local. Pase los argumentos de su motor después de --:

alti rtl synthesize --runner local --project "$PROJECT" -- --top top rtl/top.sv > "$PROJECT/synth-compat.json"

Para RTL compiler execution options must follow the explicit subcommand, coloque --runner local y --project después de check, coverage o hierarchy, como se muestra arriba.

Mapear una netlist combinacional a celdas

Guarde un ejemplo combinacional independiente y una biblioteca Liberty pequeña. Sintetice su netlist y, después, mapee cada celda lógica a una celda de biblioteca con una función equivalente.

cat > "$PROJECT/rtl/map-example.sv" <<'SV'
module top(input logic a, input logic b, output logic y);
  logic n;
  assign n = a & b;
  assign y = ~n;
endmodule
SV
cat > "$PROJECT/map-example.lib" <<'LIB'
library (neutral) {
  cell (AND2) {
    area : 2.0;
    pin (A) { direction : input; }
    pin (B) { direction : input; }
    pin (Y) { direction : output; function : "A & B"; }
  }
  cell (INV) {
    area : 1.0;
    pin (A) { direction : input; }
    pin (Y) { direction : output; function : "!A"; }
  }
}
LIB
alti rtl synth --project "$PROJECT" --top top --netlist-only rtl/map-example.sv > "$PROJECT/map-netlist.json"
alti rtl map --project "$PROJECT" --netlist map-netlist.json --liberty map-example.lib > "$PROJECT/map-report.json"
jq -c '{schema, mapped_cell_count, total_area}' "$PROJECT/map-report.json"

{"schema":"rtl-liberty-direct-map-report-0","mapped_cell_count":2,"total_area":"3.0"}

Para no direct Liberty cell covers generic kind seguido de un tipo de celda, proporcione una biblioteca con la función booleana correspondiente y un valor positivo de area, y vuelva a ejecutar el comando de mapeo.

Comprobar una selección de destino y sus fuentes

Lea el contrato de análisis del destino y el registro de disponibilidad y, después, compruebe un paquete de fuentes. La admisión registra sus selecciones y el resumen criptográfico de las fuentes. La comprobación previa estructural devuelve diagnósticos y productos de cobertura y jerarquía.

alti rtl target-analysis capabilities
alti rtl target-analysis readiness
jq '{schema:"rtl-source-bundle.v1",sources:[.request.sources[] | {path,text:.source}],roots:[.request.sources[].path],include_dirs:[],defines:[],tops:[.request.top]}' "$PROJECT/sim.json" > "$PROJECT/target-sources.json"
DEADLINE_MS="$(( $(date +%s) * 1000 + 60000 ))"
TARGET_ARGS=(--module top --top top --targets generic-asic --primary-target generic-asic
  --tools schematic,evidence --report-detail standard --profile local-example
  --cpu-slots 1 --memory-bytes 536870912 --max-wall-time-ms 5000
  --deadline-unix-ms "$DEADLINE_MS")
alti rtl target-analysis admit "${TARGET_ARGS[@]}" < "$PROJECT/target-sources.json" > "$PROJECT/target-admission.json"
jq -c '{schema, structuralPreflightAvailable}' "$PROJECT/target-admission.json"
alti rtl target-analysis preflight "${TARGET_ARGS[@]}" < "$PROJECT/target-sources.json" > "$PROJECT/target-preflight.json"
jq -r '.schema' "$PROJECT/target-preflight.json"

{"schema":"altifigence.rtl.target-analysis-direct-admission.v1","structuralPreflightAvailable":true}
altifigence.rtl.target-analysis-direct-result.v1

local-example es la selección de perfil registrada por este ejemplo. Mantenga tops igual al --top solicitado. Para target Analysis source bundle is invalid: source/root/include/define/top cardinality is invalid, compruebe que sources y roots contengan la fuente y que tops contenga ese único nombre de módulo superior.

Ejecutar el contrato de simulación de cuatro estados

Reutilice la fuente de sim.json con una solicitud temporizada de cuatro estados. Los valores son las cadenas 0, 1, X y Z, con el bit menos significativo primero. Este ejemplo utiliza un reloj, un reinicio y una programación temporal de entradas.

jq '{schema:.schema,version:1,operationId:"altifigence.rtl.simulate.v2",request:{
  top:.request.top,sources:.request.sources,
  clocks:[{port:"clk",periodPs:1000,phasePs:500}],
  resets:[{port:"rst",activeLevel:"active_high",changes:[
    {timePs:0,valueLsb0:["1"]},{timePs:1000,valueLsb0:["0"]}]}],
  inputSchedules:[{port:"d",changes:[
    {timePs:0,valueLsb0:["0"]},{timePs:1000,valueLsb0:["1"]}]}],
  initialRegisterValues:["0"],
  limits:{maxCyclesPerClock:4,maxTimePs:4000,maxEvents:64}
}}' "$PROJECT/sim.json" > "$PROJECT/sim-v2.json"
alti rtl simulate-v2 admit --project "$PROJECT" sim-v2.json > "$PROJECT/v2-admission.json"
alti rtl simulate-v2 preflight --project "$PROJECT" sim-v2.json > "$PROJECT/v2-preflight.json"
alti rtl simulate-v2 run --project "$PROJECT" sim-v2.json > "$PROJECT/v2-result.json"
jq -r '.schema' "$PROJECT/v2-admission.json" "$PROJECT/v2-preflight.json"
jq -r '.artifact.payload.schema' "$PROJECT/v2-result.json"

altifigence.rtl.simulation-admission.v2
altifigence.rtl.simulation-preflight.v2
altifigence.rtl.simulation-receipt.v2

Compruebe que el estado de salida sea 0 en cada paso. La admisión comprueba la solicitud temporizada; la comprobación previa prepara su netlist sintetizada; la ejecución produce la traza, la forma de onda, el resumen y la procedencia. Utilice un valor par de periodPs y un valor de phasePs menor que el período.

Comandos de motor de la CLI