Simular RTL salvo e guardar o resultado — Altifigence Documentation

Salve uma solicitação limitada de simulação RTL, passe-a por admit e preflight, execute-a e, depois, armazene, liste e reabra o resultado no seu projeto.

Use o Altifigence CLI 0.1.9 no Linux para simular SystemVerilog salvo com o mecanismo RTL incluído. Os comandos de simulação admit, preflight e run leem, cada um, um arquivo de solicitação dentro do seu projeto e imprimem JSON. Para ler o contrato de simulação de quatro estados com múltiplos clocks, execute alti rtl simulate-v2 capabilities.

Salvar uma solicitação de simulação

Crie a pasta do projeto e salve esta solicitação nela como sim.json. Use exatamente estas quatro chaves de nível superior. A solicitação contém o código-fonte SystemVerilog, a porta e o período do clock, um reset opcional, os valores iniciais dos registradores e um vetor 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
    }
  }
}

Forneça, em cada ciclo, todas as entradas de nível superior, exceto o clock e o reset, com o bit menos significativo primeiro. O mecanismo gera o clock e ativa o reset nos primeiros assertCycles ciclos. Mantenha clock.periodPs de 2 a 1000000000. Defina limits.maxCycles do número de ciclos até 32768 e limits.maxTimePs de ciclos × periodPs até 1000000000000. O arquivo de solicitação pode ter até 272629760 bytes.

Verificar a solicitação antes de executar

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"

Exija o status de saída 0 em cada comando. Admit verifica a estrutura e os limites da solicitação e retorna altifigence.rtl.simulation-admission.v1 com admitted em true; para esta solicitação, informa cycleCount 4, transitionStepCount 8 e simulatedTimePs 4000. Preflight também sintetiza o código-fonte em uma netlist lógica e retorna altifigence.rtl.simulation-preflight.v1 com as portas de entrada, as portas de saída e os registradores. A linha do jq imprime:

["q"]

Admit e preflight são verificações prévias. A simulação só é executada com run.

Executar a simulação

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"

Exija o status de saída 0. O resultado tem o esquema altifigence.rtl.operation-result.v1 e operationId altifigence.rtl.simulate.v1. Seu artefato é um comprovante altifigence.rtl.simulation-receipt.v1 com o preflight, um trace por etapas de evento, uma forma de onda VCD, um resumo e a procedência. Para esta solicitação, a saída final é:

{"q":[false]}

O mecanismo incluído sintetiza o design e o executa com seu próprio simulador de etapas de evento de dois estados. wave.vcd usa uma escala de tempo de 1ps.

Inspecionar e sintetizar o código-fonte

Salve o mesmo módulo como um arquivo do projeto e, depois, gere o esquemático dele e sintetize-o. Os caminhos dos arquivos de código-fonte são relativos ao projeto.

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"

Exija o status de saída 0. A linha do jq imprime:

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

O documento também contém topModule, modules, instances, nets, connections, diagnostics e unsupported. Seu status é complete ou partial; um documento failed termina com o status de saída 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"

Exija o status de saída 0. Synth imprime a netlist lógica e seu relatório de síntese. Para este módulo, a linha do jq imprime:

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

Se synth parar com alti-rtl: synth requires at least one SystemVerilog file, adicione o caminho do arquivo de código-fonte, como rtl/top.sv, depois das opções.

Guardar e reabrir o 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 o resultado completo e o grava em .altifigence/artifacts/rtl/ no projeto. Seu manifesto altifigence.rtl.artifact-manifest.v1 contém entryId, o SHA-256 do resultado armazenado e relativePath results/<entryId>.json. List imprime todos os manifestos; show imprime o JSON do resultado armazenado. Um resultado pode ter até 67108864 bytes.

Resolver erros

Para RTL simulation request must be the exact altifigence.rtl.simulate.v1 envelope, inclua no arquivo exatamente as chaves schema, version, operationId e request com os valores mostrados acima.

Para RTL simulation request must be a normalized project-relative path, passe o caminho relativo ao projeto, como sim.json, sem ./ ou / no início.

O mecanismo imprime os erros da solicitação depois de alti-rtl: e termina com o status de saída 2. Para RTL simulation resource limit exceeded for stimulus cycles: observed 5, maximum 4, aumente limits.maxCycles para o número de ciclos e execute admit novamente.

Para RTL simulation resource limit exceeded for simulated time ps: observed 5000, maximum 4000, aumente limits.maxTimePs para pelo menos o número de ciclos × clock.periodPs.

Para RTL artifact entry does not exist: seguido de um ID, copie um entryId de alti rtl artifact list e execute show novamente.

Verificar e analisar fontes salvas

Use o arquivo rtl/top.sv salvo da seção anterior. Confira seus diagnósticos, examine a cobertura do verificador e a hierarquia e leia a análise nativa de símbolos. Mantenha as opções de execução após o subcomando do 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"}

A forma de compatibilidade synthesize também executa o sintetizador local. Passe os argumentos do mecanismo após --:

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 e --project após check, coverage ou hierarchy, como mostrado acima.

Mapear uma netlist combinacional para células

Salve um exemplo combinacional separado e uma pequena biblioteca Liberty. Sintetize sua netlist e mapeie cada célula lógica para uma célula da biblioteca com função 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 um tipo de célula, forneça uma biblioteca com a função booleana correspondente e um valor positivo de area e execute o comando de mapeamento novamente.

Verificar uma seleção de destino e suas fontes

Leia o contrato de análise de destino e o registro de prontidão e verifique um pacote de fontes. A admissão registra suas seleções e o resumo criptográfico das fontes. O preflight estrutural retorna diagnósticos e produtos de cobertura e hierarquia.

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 é a seleção de perfil registrada por este exemplo. Mantenha tops igual ao --top solicitado. Para target Analysis source bundle is invalid: source/root/include/define/top cardinality is invalid, confira se sources e roots contêm a fonte e se tops contém esse único nome de módulo de topo.

Executar o contrato de simulação de quatro estados

Reutilize a fonte de sim.json com uma solicitação temporizada de quatro estados. Os valores são as strings 0, 1, X e Z, com o bit menos significativo primeiro. Este exemplo usa um clock, um reset e uma programação 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

Exija o status de saída 0 em cada etapa. A admissão verifica a solicitação temporizada; o preflight prepara sua netlist sintetizada; a execução produz o rastreamento, a forma de onda, o resumo e a procedência. Use um valor par de periodPs e um valor de phasePs menor que o período.

Comandos de engine da CLI